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; }