static char * get_passphrase(struct mailprivacy * privacy,
char * user_id)
{
chashdatum key;
chashdatum value;
int r;
char * passphrase;
char buf[MAX_EMAIL_SIZE];
char * n;
strncpy(buf, user_id, sizeof(buf));
buf[sizeof(buf) - 1] = '\0';
for(n = buf ; * n != '\0' ; n ++)
* n = toupper((unsigned char) * n);
if (passphrase_hash == NULL)
return NULL;
key.data = buf;
key.len = strlen(buf) + 1;
r = chash_get(passphrase_hash, &key, &value);
if (r < 0)
return NULL;
passphrase = strdup(value.data);
return passphrase;
}
int mailmbox_fetch_msg_headers_no_lock(struct mailmbox_folder * folder,
uint32_t num, char ** result,
size_t * result_len)
{
struct mailmbox_msg_info * info;
int res;
chashdatum key;
chashdatum data;
int r;
key.data = #
key.len = sizeof(num);
r = chash_get(folder->mb_hash, &key, &data);
if (r < 0) {
res = MAILMBOX_ERROR_MSG_NOT_FOUND;
goto err;
}
info = data.data;
if (info->msg_deleted) {
res = MAILMBOX_ERROR_MSG_NOT_FOUND;
goto err;
}
* result = folder->mb_mapping + info->msg_headers;
* result_len = info->msg_headers_len;
return MAILMBOX_NO_ERROR;
err:
return res;
}
static struct storage_ref_info *
get_storage_ref_info(struct mailengine * engine,
struct mailstorage * storage)
{
chashdatum key;
chashdatum data;
int r;
struct storage_ref_info * ref_info;
key.data = &storage;
key.len = sizeof(storage);
#ifdef LIBETPAN_REENTRANT
pthread_mutex_lock(&engine->storage_hash_lock);
#endif
r = chash_get(engine->storage_hash, &key, &data);
#ifdef LIBETPAN_REENTRANT
pthread_mutex_unlock(&engine->storage_hash_lock);
#endif
if (r < 0)
return NULL;
ref_info = data.data;
return ref_info;
}
static void
remove_storage_ref_info(struct mailengine * engine,
struct mailstorage * storage)
{
chashdatum key;
chashdatum data;
struct storage_ref_info * ref_info;
key.data = &storage;
key.len = sizeof(storage);
#ifdef LIBETPAN_REENTRANT
pthread_mutex_lock(&engine->storage_hash_lock);
#endif
chash_get(engine->storage_hash, &key, &data);
ref_info = data.data;
if (ref_info != NULL) {
storage_ref_info_free(ref_info);
chash_delete(engine->storage_hash, &key, NULL);
}
#ifdef LIBETPAN_REENTRANT
pthread_mutex_unlock(&engine->storage_hash_lock);
#endif
}
struct mail_flags *
mail_flags_store_get(struct mail_flags_store * flags_store, uint32_t indx)
{
struct mail_flags * flags;
chashdatum key;
chashdatum value;
int r;
unsigned int tab_index;
mailmessage * msg;
key.data = &indx;
key.len = sizeof(indx);
r = chash_get(flags_store->fls_hash, &key, &value);
if (r < 0)
return NULL;
#if 0
flags = mail_flags_dup((struct mail_flags *) value.data);
#endif
tab_index = * (unsigned int *) value.data;
msg = carray_get(flags_store->fls_tab, tab_index);
if (msg->msg_flags == NULL)
return NULL;
flags = mail_flags_dup(msg->msg_flags);
return flags;
}
int mail_cache_db_clean_up(struct mail_cache_db * cache_db,
chash * exist)
{
DB * dbp;
int r;
DBT db_key;
DBT db_data;
dbp = cache_db->internal_database;
r = dbp->seq(dbp, &db_key, &db_data, R_FIRST);
if (r == -1)
return -1;
while (r == 0) {
chashdatum hash_key;
chashdatum hash_data;
hash_key.data = db_key.data;
hash_key.len = db_key.size;
r = chash_get(exist, &hash_key, &hash_data);
if (r < 0) {
r = dbp->del(dbp, &db_key, 0);
if (r != 0)
return -1;
}
r = dbp->seq(dbp, &db_key, &db_data, R_NEXT);
if (r < 0)
return -1;
}
return 0;
}
static int mbox_initialize(mailmessage * msg_info)
{
struct generic_message_t * msg;
int r;
char * uid;
char static_uid[PATH_MAX];
struct mailmbox_msg_info * info;
struct mailmbox_folder * folder;
int res;
chashdatum key;
chashdatum data;
folder = get_mbox_session(msg_info);
if (folder == NULL) {
res = MAIL_ERROR_BAD_STATE;
goto err;
}
key.data = (char *) &msg_info->msg_index;
key.len = sizeof(msg_info->msg_index);
r = chash_get(folder->mb_hash, &key, &data);
if (r < 0) {
res = MAIL_ERROR_MSG_NOT_FOUND;
goto err;
}
info = (struct mailmbox_msg_info *) data.data;
snprintf(static_uid, PATH_MAX, "%u-%lu",
msg_info->msg_index, (unsigned long) info->msg_body_len);
uid = strdup(static_uid);
if (uid == NULL) {
res = MAIL_ERROR_MEMORY;
goto err;
}
r = mailmessage_generic_initialize(msg_info);
if (r != MAIL_NO_ERROR) {
free(uid);
res = r;
goto err;
}
msg = msg_info->msg_data;
msg->msg_prefetch = mbox_prefetch;
msg->msg_prefetch_free = mbox_prefetch_free;
msg_info->msg_uid = uid;
return MAIL_NO_ERROR;
err:
return res;
}
int mail_cache_db_clean_up(struct mail_cache_db * cache_db,
chash * exist)
{
int r;
MDB_env *env;
MDB_txn *txn;
MDB_dbi dbi;
MDB_cursor *cursor;
MDB_val mdb_key;
MDB_val mdb_val;
env = cache_db->internal_database;
r = mdb_txn_begin(env, NULL, 0, &txn);
if (r != 0)
return -1;
r = mdb_dbi_open(txn, NULL, 0, &dbi);
if (r != 0)
goto error;
r = mdb_cursor_open(txn, dbi, &cursor);
if (r != 0)
goto error;
r = mdb_cursor_get(cursor, &mdb_key, &mdb_val, MDB_FIRST);
if (r != 0)
goto cursor_error;
while (r == 0) {
chashdatum hash_key;
chashdatum hash_data;
hash_key.data = mdb_key.mv_data;
hash_key.len = (unsigned int) mdb_key.mv_size;
r = chash_get(exist, &hash_key, &hash_data);
if (r < 0) {
r = mdb_cursor_del(cursor, 0);
if (r != 0)
goto cursor_error;
}
r = mdb_cursor_get(cursor, &mdb_key, &mdb_val, MDB_NEXT);
}
mdb_txn_commit(txn);
return 0;
cursor_error:
mdb_cursor_close(cursor);
error:
mdb_txn_abort(txn);
return -1;
}
static int get_flags(mailmessage * msg_info,
struct mail_flags ** result)
{
chashdatum key;
chashdatum value;
struct maildir * md;
struct mail_flags * flags;
struct maildir_session_state_data * data;
struct maildir_msg * md_msg;
int r;
uint32_t driver_flags;
clist * ext;
if (msg_info->msg_flags != NULL) {
* result = msg_info->msg_flags;
return MAIL_NO_ERROR;
}
data = get_session_data(msg_info);
flags = mail_flags_store_get(data->md_flags_store,
msg_info->msg_index);
if (flags != NULL) {
msg_info->msg_flags = flags;
* result = msg_info->msg_flags;
return MAIL_NO_ERROR;
}
md = get_maildir_session(msg_info);
if (md == NULL)
return MAIL_ERROR_BAD_STATE;
key.data = msg_info->msg_uid;
key.len = strlen(msg_info->msg_uid);
r = chash_get(md->mdir_msg_hash, &key, &value);
if (r < 0)
return MAIL_ERROR_MSG_NOT_FOUND;
md_msg = value.data;
driver_flags = maildirdriver_maildir_flags_to_flags(md_msg->msg_flags);
ext = clist_new();
if (ext == NULL)
return MAIL_ERROR_MEMORY;
msg_info->msg_flags = mail_flags_new(driver_flags, ext);
* result = msg_info->msg_flags;
return MAIL_NO_ERROR;
}
static struct etpan_thread * get_thread(Folder * folder)
{
struct etpan_thread * thread;
chashdatum key;
chashdatum value;
key.data = &folder;
key.len = sizeof(folder);
chash_get(nntp_hash, &key, &value);
thread = value.data;
return thread;
}
static int mhdriver_cached_get_message_by_uid(mailsession * session,
const char * uid,
mailmessage ** result)
{
uint32_t indx;
char *p;
struct mailmh_msg_info * mh_msg_info;
struct mailmh_folder * folder;
time_t mtime;
char * mtime_p;
chashdatum key;
chashdatum data;
int r;
if (uid == NULL)
return MAIL_ERROR_INVAL;
indx = strtoul(uid, &p, 10);
if (p == uid || * p != '-')
return MAIL_ERROR_INVAL;
folder = get_mh_cur_folder(session);
mh_msg_info = NULL;
key.data = &indx;
key.len = sizeof(indx);
r = chash_get(folder->fl_msgs_hash, &key, &data);
if (r < 0)
return MAIL_ERROR_MSG_NOT_FOUND;
mh_msg_info = data.data;
mtime_p = p + 1;
mtime = strtoul(mtime_p, &p, 10);
if ((* p == '-') && (mtime == mh_msg_info->msg_mtime)) {
size_t size;
char *size_p;
size_p = p + 1;
size = strtoul(size_p, &p, 10);
if ((* p == '\0') && (size == mh_msg_info->msg_size))
return mhdriver_cached_get_message(session, indx, result);
}
else if (*p != '-') {
return MAIL_ERROR_INVAL;
}
return MAIL_ERROR_MSG_NOT_FOUND;
}
static int
test_chash(void)
{
test_start("chash");
chash_t h;
chash_init(&h, 12);
for (int i = 0; i < 1024; i++) {
chash_set(&h, i, (chash_item_t) 0x3F1);
}
for (int i = 0; i < 1024; i++) {
int t = (int) chash_get(&h, i);
test_assert(t == 0x3F1);
}
chash_remove(&h, 123);
test_assert(chash_get(&h, 123) == NULL);
int f = chash_find_free(&h, 100, 200);
test_assert(f == 123);
for (int i = 0; i < 1024; i++) {
chash_remove(&h, i);
}
chash_release(&h);
return test_success();
}
static int result_is_mmapstr(struct mailprivacy * privacy, char * str)
{
chashdatum key;
chashdatum data;
int r;
key.data = &str;
key.len = sizeof(str);
r = chash_get(privacy->mmapstr, &key, &data);
if (r < 0)
return 0;
else
return 1;
}
static int mime_is_registered(struct mailprivacy * privacy,
struct mailmime * mime)
{
chashdatum key;
chashdatum data;
int r;
key.data = &mime;
key.len = sizeof(mime);
r = chash_get(privacy->mime_ref, &key, &data);
if (r < 0)
return 0;
else
return 1;
}
int mail_cache_db_clean_up(struct mail_cache_db * cache_db,
chash * exist)
{
DB * dbp;
int r;
DBC * dbcp;
DBT db_key;
DBT db_data;
dbp = cache_db->internal_database;
#if DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR < 6
r = dbp->cursor(dbp, NULL, &dbcp);
#else
r = dbp->cursor(dbp, NULL, &dbcp, 0);
#endif
if (r != 0)
return -1;
memset(&db_key, 0, sizeof(db_key));
memset(&db_data, 0, sizeof(db_data));
while (1) {
chashdatum hash_key;
chashdatum hash_data;
r = dbcp->c_get(dbcp, &db_key, &db_data, DB_NEXT);
if (r != 0)
break;
hash_key.data = db_key.data;
hash_key.len = db_key.size;
r = chash_get(exist, &hash_key, &hash_data);
if (r < 0) {
r = dbcp->c_del(dbcp, 0);
if (r != 0)
return -1;
}
}
r = dbcp->c_close(dbcp);
if (r != 0)
return -1;
return 0;
}
int mmap_string_unref(char * str)
{
MMAPString * string;
chash * ht;
chashdatum key;
chashdatum data;
int r;
if (str == NULL)
return -1;
MUTEX_LOCK(&mmapstring_lock);
ht = mmapstring_hashtable;
if (ht == NULL) {
MUTEX_UNLOCK(&mmapstring_lock);
return -1;
}
key.data = &str;
key.len = sizeof(str);
r = chash_get(ht, &key, &data);
if (r < 0)
string = NULL;
else
string = data.data;
if (string != NULL) {
chash_delete(ht, &key, NULL);
if (chash_count(ht) == 0) {
chash_free(ht);
mmapstring_hashtable = NULL;
}
}
MUTEX_UNLOCK(&mmapstring_lock);
if (string != NULL) {
mmap_string_free(string);
return 0;
}
else
return -1;
}
static newsnntp * get_nntp(Folder * folder)
{
newsnntp * nntp;
chashdatum key;
chashdatum value;
int r;
key.data = &folder;
key.len = sizeof(folder);
r = chash_get(session_hash, &key, &value);
if (r < 0)
return NULL;
nntp = value.data;
debug_print("found nntp %p\n", nntp);
return nntp;
}
static struct message_ref_elt *
folder_info_get_msg_ref(struct folder_ref_info * ref_info, mailmessage * msg)
{
chashdatum key;
chashdatum data;
struct message_ref_elt * ref_elt;
int r;
key.data = &msg;
key.len = sizeof(msg);
r = chash_get(ref_info->msg_hash, &key, &data);
if (r < 0)
return NULL;
ref_elt = data.data;
return ref_elt;
}
static mailmessage *
folder_info_get_msg_by_uid(struct folder_ref_info * ref_info,
char * uid)
{
chashdatum key;
chashdatum data;
mailmessage * msg;
int r;
key.data = uid;
key.len = strlen(uid);
r = chash_get(ref_info->uid_hash, &key, &data);
if (r < 0)
return NULL;
msg = data.data;
return msg;
}
static struct folder_ref_info *
storage_get_folder_ref(struct storage_ref_info * ref_info,
struct mailfolder * folder)
{
struct folder_ref_info * folder_ref;
chashdatum key;
chashdatum value;
int r;
key.data = &folder;
key.len = sizeof(folder);
r = chash_get(ref_info->folder_ref_info, &key, &value);
if (r < 0)
return NULL;
folder_ref = value.data;
return folder_ref;
}
static int mboxdriver_get_message_by_uid(mailsession * session,
const char * uid,
mailmessage ** result)
{
uint32_t num;
char * p;
chashdatum key;
chashdatum data;
struct mailmbox_msg_info * info;
struct mailmbox_folder * folder;
int r;
if (uid == NULL)
return MAIL_ERROR_INVAL;
num = strtoul(uid, &p, 10);
if (p == uid || * p != '-')
return MAIL_ERROR_INVAL;
folder = get_mbox_session(session);
if (folder == NULL)
return MAIL_ERROR_BAD_STATE;
key.data = #
key.len = sizeof(num);
r = chash_get(folder->mb_hash, &key, &data);
if (r == 0) {
char * body_len_p = p + 1;
size_t body_len;
info = data.data;
/* Check if the cached message has the same UID */
body_len = strtoul(body_len_p, &p, 10);
if (p == body_len_p || * p != '\0')
return MAIL_ERROR_INVAL;
if (body_len == info->msg_body_len)
return mboxdriver_get_message(session, num, result);
}
return MAIL_ERROR_MSG_NOT_FOUND;
}
static int msg_is_modified(struct mailprivacy * privacy,
mailmessage * msg)
{
chashdatum key;
chashdatum data;
int r;
if (privacy == NULL)
return 0;
key.data = &msg;
key.len = sizeof(msg);
r = chash_get(privacy->msg_ref, &key, &data);
if (r < 0)
return 0;
else
return 1;
}
struct mailmh_folder * mailmh_folder_find(struct mailmh_folder * root,
const char * filename)
{
int r;
char pathname[PATH_MAX];
char * p;
chashdatum key;
chashdatum data;
struct mailmh_folder * folder;
char * start;
if (strcmp(root->fl_filename, filename) == 0)
return root;
strncpy(pathname, filename, PATH_MAX);
pathname[PATH_MAX - 1] = 0;
start = pathname + strlen(root->fl_filename) + 1;
p = strchr(start, MAIL_DIR_SEPARATOR);
if (p != NULL) {
* p = 0;
root = mailmh_folder_find(root, pathname);
if (root != NULL) {
folder = mailmh_folder_find(root, filename);
if (folder == NULL)
return NULL;
return folder;
}
return NULL;
}
else {
key.data = pathname;
key.len = strlen(pathname);
r = chash_get(root->fl_subfolders_hash, &key, &data);
if (r < 0)
return NULL;
return data.data;
}
}
static int append_message_flags(mailsession * session,
const char * message, size_t size, struct mail_flags * flags)
{
struct maildir * md;
int r;
char uid[PATH_MAX];
struct maildir_msg * md_msg;
chashdatum key;
chashdatum value;
uint32_t md_flags;
md = get_maildir_session(session);
if (md == NULL)
return MAIL_ERROR_BAD_STATE;
r = maildir_message_add_uid(md, message, size,
uid, sizeof(uid));
if (r != MAILDIR_NO_ERROR)
return maildirdriver_maildir_error_to_mail_error(r);
if (flags == NULL)
goto exit;
key.data = uid;
key.len = strlen(uid);
r = chash_get(md->mdir_msg_hash, &key, &value);
if (r < 0)
goto exit;
md_msg = value.data;
md_flags = maildirdriver_flags_to_maildir_flags(flags->fl_flags);
r = maildir_message_change_flags(md, uid, md_flags);
if (r != MAILDIR_NO_ERROR)
goto exit;
return MAIL_NO_ERROR;
exit:
return MAIL_NO_ERROR;
}
static clist * get_list(struct mailprivacy * privacy, mailmessage * msg)
{
clist * encryption_id_list;
encryption_id_list = NULL;
if (encryption_id_hash != NULL) {
chashdatum key;
chashdatum value;
int r;
key.data = &msg;
key.len = sizeof(msg);
r = chash_get(encryption_id_hash, &key, &value);
if (r == 0) {
encryption_id_list = value.data;
}
}
return encryption_id_list;
}
static int mh_initialize(mailmessage * msg_info)
{
struct generic_message_t * msg;
int r;
char * uid;
char static_uid[PATH_MAX];
struct mailmh_msg_info * mh_msg_info;
chashdatum key;
chashdatum data;
struct mailmh_folder * folder;
folder = get_mh_cur_folder(msg_info);
key.data = &msg_info->msg_index;
key.len = sizeof(msg_info->msg_index);
r = chash_get(folder->fl_msgs_hash, &key, &data);
if (r < 0)
return MAIL_ERROR_INVAL;
mh_msg_info = data.data;
snprintf(static_uid, PATH_MAX, "%u-%lu-%lu", msg_info->msg_index,
mh_msg_info->msg_mtime, (unsigned long) mh_msg_info->msg_size);
uid = strdup(static_uid);
if (uid == NULL)
return MAIL_ERROR_MEMORY;
r = mailmessage_generic_initialize(msg_info);
if (r != MAIL_NO_ERROR) {
free(uid);
return r;
}
msg = msg_info->msg_data;
msg->msg_prefetch = mh_prefetch;
msg->msg_prefetch_free = mh_prefetch_free;
msg_info->msg_uid = uid;
return MAIL_NO_ERROR;
}
static int
get_cached_envelope(struct mail_cache_db * cache_db, MMAPString * mmapstr,
mailsession * session, uint32_t num,
struct mailimf_fields ** result)
{
int r;
char keyname[PATH_MAX];
struct mailimf_fields * fields;
int res;
struct mailmh_folder * folder;
struct mailmh_msg_info * msg_info;
chashdatum key;
chashdatum data;
folder = get_mh_cur_folder(session);
key.data = #
key.len = sizeof(num);
r = chash_get(folder->fl_msgs_hash, &key, &data);
if (r < 0)
return MAIL_ERROR_CACHE_MISS;
msg_info = data.data;
snprintf(keyname, PATH_MAX, "%u-%lu-%lu-envelope",
num, (unsigned long) msg_info->msg_mtime,
(unsigned long) msg_info->msg_size);
r = generic_cache_fields_read(cache_db, mmapstr, keyname, &fields);
if (r != MAIL_NO_ERROR) {
res = r;
goto err;
}
* result = fields;
return MAIL_NO_ERROR;
err:
return res;
}
void nntp_done(Folder * folder)
{
struct etpan_thread * thread;
chashdatum key;
chashdatum value;
int r;
key.data = &folder;
key.len = sizeof(folder);
r = chash_get(nntp_hash, &key, &value);
if (r < 0)
return;
thread = value.data;
etpan_thread_unbind(thread);
chash_delete(nntp_hash, &key, NULL);
debug_print("remove thread");
}
static char * get_file(chash * hash, char * email)
{
chashdatum key;
chashdatum data;
char buf[MAX_EMAIL_SIZE];
char * n;
int r;
strncpy(buf, email, sizeof(buf));
buf[sizeof(buf) - 1] = '\0';
for(n = buf ; * n != '\0' ; n ++)
* n = toupper((unsigned char) * n);
strip_string(buf);
key.data = buf;
key.len = strlen(buf);
r = chash_get(hash, &key, &data);
if (r < 0)
return NULL;
return data.data;
}
int mailmh_folder_remove_message(struct mailmh_folder * folder,
uint32_t indx)
{
char * filename;
struct mailmh_msg_info * msg_info;
int res;
int r;
chashdatum key;
chashdatum data;
r = mailmh_folder_get_message_filename(folder, indx, &filename);
if (filename == NULL) {
res = r;
goto err;
}
if (unlink(filename) == -1) {
res = MAILMH_ERROR_FILE;
goto free;
}
key.data = &indx;
key.len = sizeof(indx);
r = chash_get(folder->fl_msgs_hash, &key, &data);
if (r == 0) {
msg_info = data.data;
carray_delete_fast(folder->fl_msgs_tab, msg_info->msg_array_index);
chash_delete(folder->fl_msgs_hash, &key, NULL);
}
return MAILMH_NO_ERROR;
free:
free(filename);
err:
return res;
}
