int
nntpdriver_get_cached_flags(struct mail_cache_db * cache_db,
MMAPString * mmapstr,
uint32_t num,
struct mail_flags ** result)
{
int r;
char keyname[PATH_MAX];
struct mail_flags * flags;
int res;
snprintf(keyname, PATH_MAX, "%u-flags", num);
r = generic_cache_flags_read(cache_db, mmapstr, keyname, &flags);
if (r != MAIL_NO_ERROR) {
res = r;
goto err;
}
* result = flags;
return MAIL_NO_ERROR;
err:
return res;
}
static int get_envelopes_list(mailsession * session,
struct mailmessage_list * env_list)
{
unsigned int i;
char key[PATH_MAX];
int r;
struct mail_cache_db * maildb;
int res;
struct db_session_state_data * data;
MMAPString * mmapstr;
data = get_data(session);
flags_store_process(session);
r = mail_cache_db_open_lock(data->db_filename, &maildb);
if (r < 0) {
res = MAIL_ERROR_FILE;
goto err;
}
mmapstr = mmap_string_new("");
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto close_db;
}
for(i = 0 ; i < carray_count(env_list->msg_tab) ; i ++) {
mailmessage * msg;
msg = carray_get(env_list->msg_tab, i);
if (msg->msg_fields == NULL) {
snprintf(key, sizeof(key), "%lu-envelope",
(unsigned long) msg->msg_index);
r = generic_cache_fields_read(maildb, mmapstr,
key, &msg->msg_fields);
}
if (msg->msg_flags == NULL) {
snprintf(key, sizeof(key), "%lu-flags",
(unsigned long) msg->msg_index);
r = generic_cache_flags_read(maildb, mmapstr,
key, &msg->msg_flags);
}
}
mmap_string_free(mmapstr);
mail_cache_db_close_unlock(data->db_filename, maildb);
return MAIL_NO_ERROR;
close_db:
mail_cache_db_close_unlock(data->db_filename, maildb);
err:
return res;
}
static int get_flags(mailmessage * msg_info,
struct mail_flags ** result)
{
char key[PATH_MAX];
int r;
struct db_session_state_data * sess_data;
struct mail_cache_db * maildb;
int res;
MMAPString * mmapstr;
sess_data = get_session_data(msg_info);
r = mail_cache_db_open_lock(sess_data->db_filename, &maildb);
if (r < 0) {
res = MAIL_ERROR_FILE;
goto err;
}
snprintf(key, sizeof(key), "%lu-flags", (unsigned long) msg_info->msg_index);
mmapstr = mmap_string_new("");
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto close_db;
}
r = generic_cache_flags_read(maildb, mmapstr,
key, &msg_info->msg_flags);
mmap_string_free(mmapstr);
if (r != MAIL_NO_ERROR) {
msg_info->msg_flags = mail_flags_new_empty();
if (msg_info->msg_flags == NULL) {
res = MAIL_ERROR_MEMORY;
goto close_db;
}
}
mail_cache_db_close_unlock(sess_data->db_filename, maildb);
* result = msg_info->msg_flags;
return MAIL_NO_ERROR;
close_db:
mail_cache_db_close_unlock(sess_data->db_filename, maildb);
err:
return res;
}
static int get_flags(mailmessage * msg_info,
struct mail_flags ** result)
{
struct mail_cache_db * cache_db_flags;
chashdatum key;
chashdatum value;
struct maildir * md;
struct mail_flags * flags;
struct maildir_cached_session_state_data * data;
struct maildir_msg * md_msg;
int r;
uint32_t driver_flags;
char filename_flags[PATH_MAX];
char keyname[PATH_MAX];
MMAPString * mmapstr;
if (msg_info->msg_flags != NULL) {
* result = msg_info->msg_flags;
return MAIL_NO_ERROR;
}
data = get_cached_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;
}
snprintf(filename_flags, PATH_MAX, "%s%c%s%c%s",
data->md_flags_directory, MAIL_DIR_SEPARATOR, data->md_quoted_mb,
MAIL_DIR_SEPARATOR, FLAGS_NAME);
r = mail_cache_db_open_lock(filename_flags, &cache_db_flags);
if (r < 0)
return MAIL_ERROR_FILE;
snprintf(keyname, PATH_MAX, "%s-flags", msg_info->msg_uid);
mmapstr = mmap_string_new("");
if (mmapstr == NULL) {
mail_cache_db_close_unlock(filename_flags, cache_db_flags);
return MAIL_ERROR_MEMORY;
}
r = generic_cache_flags_read(cache_db_flags, mmapstr, keyname, &flags);
mmap_string_free(mmapstr);
mail_cache_db_close_unlock(filename_flags, cache_db_flags);
if (r != MAIL_NO_ERROR) {
flags = mail_flags_new_empty();
if (flags == NULL)
return MAIL_ERROR_MEMORY;
}
md = get_maildir_session(msg_info);
if (md == NULL)
return MAIL_ERROR_BAD_STATE;
key.data = msg_info->msg_uid;
key.len = (unsigned int) 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);
flags->fl_flags = driver_flags;
msg_info->msg_flags = flags;
* result = msg_info->msg_flags;
return MAIL_NO_ERROR;
}
static int status_folder(mailsession * session, const char * mb,
uint32_t * result_messages, uint32_t * result_recent,
uint32_t * result_unseen)
{
struct mail_cache_db * maildb;
char key_value[PATH_MAX];
MMAPString * mmapstr;
uint32_t messages;
uint32_t recent;
uint32_t unseen;
struct db_session_state_data * data;
int r;
int res;
carray * msglist;
unsigned int i;
data = get_data(session);
flags_store_process(session);
r = mail_cache_db_open_lock(data->db_filename, &maildb);
if (r < 0) {
res = MAIL_ERROR_FILE;
goto err;
}
r = db_get_message_list(maildb, &msglist);
if (r != MAIL_NO_ERROR) {
res = r;
goto close_db;
}
mmapstr = mmap_string_new("");
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto free_list;
}
messages = 0;
recent = 0;
unseen = 0;
for(i = 0 ; i < carray_count(msglist) ; i ++) {
uint32_t num;
uint32_t * msg;
struct mail_flags * flags;
msg = carray_get(msglist, i);
num = * msg;
free(msg);
carray_set(msglist, i, NULL);
messages ++;
snprintf(key_value, sizeof(key_value), "%lu-flags", (unsigned long) num);
r = generic_cache_flags_read(maildb, mmapstr, key_value, &flags);
if (r == MAIL_NO_ERROR) {
if ((flags->fl_flags & MAIL_FLAG_NEW) != 0) {
recent ++;
}
if ((flags->fl_flags & MAIL_FLAG_SEEN) == 0) {
unseen ++;
}
mail_flags_free(flags);
}
}
mmap_string_free(mmapstr);
carray_free(msglist);
mail_cache_db_close_unlock(data->db_filename, maildb);
* result_messages = messages;
* result_unseen = unseen;
* result_recent = recent;
return MAIL_NO_ERROR;
free_list:
for(i = 0 ; i < carray_count(msglist) ; i ++) {
uint32_t * msg;
msg = carray_get(msglist, i);
if (msg != NULL)
free(msg);
}
carray_free(msglist);
close_db:
mail_cache_db_close_unlock(data->db_filename, maildb);
err:
return res;
}
static int expunge_folder(mailsession * session)
{
int r;
char key_value[PATH_MAX];
struct mail_cache_db * maildb;
carray * msglist;
unsigned int i;
struct db_session_state_data * data;
int res;
chash * msg_table;
MMAPString * mmapstr;
data = get_data(session);
flags_store_process(session);
r = mail_cache_db_open_lock(data->db_filename, &maildb);
if (r < 0) {
res = MAIL_ERROR_FILE;
goto err;
}
r = db_get_message_list(maildb, &msglist);
if (r != MAIL_NO_ERROR) {
res = r;
goto close_db;
}
msg_table = chash_new(CHASH_DEFAULTSIZE, CHASH_COPYKEY);
if (msg_table == NULL) {
res = MAIL_ERROR_MEMORY;
goto free_msglist;
}
mmapstr = mmap_string_new("");
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto free_msgtable;
}
i = 0;
while (i < carray_count(msglist)) {
uint32_t num;
uint32_t * msg;
chashdatum key;
chashdatum value;
struct mail_flags * flags;
int deleted;
msg = carray_get(msglist, i);
num = * msg;
deleted = 0;
snprintf(key_value, sizeof(key_value), "%lu-flags",
(unsigned long) num);
r = generic_cache_flags_read(maildb, mmapstr, key_value, &flags);
if (r == MAIL_NO_ERROR) {
if ((flags->fl_flags & MAIL_FLAG_DELETED) != 0)
deleted = 1;
}
if (!deleted) {
snprintf(key_value, sizeof(key_value), "%lu", (unsigned long) num);
key.data = key_value;
key.len = strlen(key_value);
chash_set(msg_table, &key, &value, NULL);
snprintf(key_value, sizeof(key_value), "%lu-envelope",
(unsigned long) num);
key.data = key_value;
key.len = strlen(key_value);
chash_set(msg_table, &key, &value, NULL);
snprintf(key_value, sizeof(key_value), "%lu-flags",
(unsigned long) num);
key.data = key_value;
key.len = strlen(key_value);
chash_set(msg_table, &key, &value, NULL);
i ++;
}
else {
free(msg);
carray_delete(msglist, i);
}
}
mmap_string_free(mmapstr);
r = mail_cache_db_clean_up(maildb, msg_table);
chash_free(msg_table);
r = db_set_message_list(maildb, msglist);
for(i = 0 ; i < carray_count(msglist) ; i ++) {
uint32_t * msg;
msg = carray_get(msglist, i);
free(msg);
}
carray_free(msglist);
mail_cache_db_close_unlock(data->db_filename, maildb);
return MAIL_NO_ERROR;
free_msgtable:
chash_free(msg_table);
free_msglist:
for(i = 0 ; i < carray_count(msglist) ; i ++) {
uint32_t * msg;
msg = carray_get(msglist, i);
free(msg);
}
close_db:
mail_cache_db_close_unlock(data->db_filename, maildb);
err:
return res;
}