static int save_xbzrle_page(QEMUFile *f, uint8_t **current_data,
ram_addr_t current_addr, RAMBlock *block,
ram_addr_t offset, int cont, bool last_stage)
{
int encoded_len = 0, bytes_sent = -1;
uint8_t *prev_cached_page;
if (!cache_is_cached(XBZRLE.cache, current_addr)) {
acct_info.xbzrle_cache_miss++;
if (!last_stage) {
if (cache_insert(XBZRLE.cache, current_addr, *current_data) == -1) {
return -1;
} else {
/* update *current_data when the page has been
inserted into cache */
*current_data = get_cached_data(XBZRLE.cache, current_addr);
}
}
return -1;
}
prev_cached_page = get_cached_data(XBZRLE.cache, current_addr);
/* save current buffer into memory */
memcpy(XBZRLE.current_buf, *current_data, TARGET_PAGE_SIZE);
/* XBZRLE encoding (if there is no overflow) */
encoded_len = xbzrle_encode_buffer(prev_cached_page, XBZRLE.current_buf,
TARGET_PAGE_SIZE, XBZRLE.encoded_buf,
TARGET_PAGE_SIZE);
if (encoded_len == 0) {
DPRINTF("Skipping unmodified page\n");
return 0;
} else if (encoded_len == -1) {
DPRINTF("Overflow\n");
acct_info.xbzrle_overflows++;
/* update data in the cache */
if (!last_stage) {
memcpy(prev_cached_page, *current_data, TARGET_PAGE_SIZE);
*current_data = prev_cached_page;
}
return -1;
}
/* we need to update the data in the cache, in order to get the same data */
if (!last_stage) {
memcpy(prev_cached_page, XBZRLE.current_buf, TARGET_PAGE_SIZE);
}
/* Send XBZRLE based compressed page */
bytes_sent = save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_XBZRLE);
qemu_put_byte(f, ENCODING_FLAG_XBZRLE);
qemu_put_be16(f, encoded_len);
qemu_put_buffer(f, XBZRLE.encoded_buf, encoded_len);
bytes_sent += encoded_len + 1 + 2;
acct_info.xbzrle_pages++;
acct_info.xbzrle_bytes += bytes_sent;
return bytes_sent;
}
static int read_max_uid_value(mailsession * session)
{
int r;
char filename[PATH_MAX];
FILE * f;
uint32_t written_uid;
int res;
struct mh_cached_session_state_data * cached_data;
struct mh_session_state_data * ancestor_data;
MMAPString * mmapstr;
size_t cur_token;
char buf[sizeof(uint32_t)];
size_t read_size;
cached_data = get_cached_data(session);
ancestor_data = get_ancestor_data(session);
snprintf(filename, PATH_MAX, "%s/%s/%s",
cached_data->mh_cache_directory,
cached_data->mh_quoted_mb, FILENAME_MAX_UID);
f = fopen(filename, "r");
if (f == NULL) {
res = MAIL_ERROR_FILE;
goto err;
}
read_size = fread(buf, 1, sizeof(uint32_t), f);
mmapstr = mmap_string_new_len(buf, read_size);
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto close;
}
cur_token = 0;
r = mailimf_cache_int_read(mmapstr, &cur_token, &written_uid);
if (r != MAIL_NO_ERROR) {
fclose(f);
res = r;
goto free_mmapstr;
}
mmap_string_free(mmapstr);
fclose(f);
if (written_uid > ancestor_data->mh_cur_folder->fl_max_index)
ancestor_data->mh_cur_folder->fl_max_index = written_uid;
return MAIL_NO_ERROR;
free_mmapstr:
mmap_string_free(mmapstr);
close:
fclose(f);
err:
return res;
}
static int mhdriver_cached_parameters(mailsession * session,
int id, void * value)
{
struct mh_cached_session_state_data * cached_data;
int r;
cached_data = get_cached_data(session);
switch (id) {
case MHDRIVER_CACHED_SET_CACHE_DIRECTORY:
strncpy(cached_data->mh_cache_directory, value, PATH_MAX);
cached_data->mh_cache_directory[PATH_MAX - 1] = '\0';
r = generic_cache_create_dir(cached_data->mh_cache_directory);
if (r != MAIL_NO_ERROR)
return r;
return MAIL_NO_ERROR;
case MHDRIVER_CACHED_SET_FLAGS_DIRECTORY:
strncpy(cached_data->mh_flags_directory, value, PATH_MAX);
cached_data->mh_flags_directory[PATH_MAX - 1] = '\0';
r = generic_cache_create_dir(cached_data->mh_flags_directory);
if (r != MAIL_NO_ERROR)
return r;
return MAIL_NO_ERROR;
}
return MAIL_ERROR_INVAL;
}
static int nntpdriver_cached_parameters(mailsession * session,
int id, void * value)
{
struct nntp_cached_session_state_data * cached_data;
int r;
cached_data = get_cached_data(session);
switch (id) {
case NNTPDRIVER_CACHED_SET_CACHE_DIRECTORY:
strncpy(cached_data->nntp_cache_directory, value, PATH_MAX);
cached_data->nntp_cache_directory[PATH_MAX - 1] = '\0';
r = generic_cache_create_dir(cached_data->nntp_cache_directory);
if (r != MAIL_NO_ERROR)
return r;
return MAIL_NO_ERROR;
case NNTPDRIVER_CACHED_SET_FLAGS_DIRECTORY:
strncpy(cached_data->nntp_flags_directory, value, PATH_MAX);
cached_data->nntp_flags_directory[PATH_MAX - 1] = '\0';
r = generic_cache_create_dir(cached_data->nntp_flags_directory);
if (r != MAIL_NO_ERROR)
return r;
return MAIL_NO_ERROR;
default:
return mailsession_parameters(get_ancestor(session), id, value);
}
}
static void read_article_seq(mailsession * session,
uint32_t * pfirst, uint32_t * plast)
{
FILE * f;
struct nntp_session_state_data * ancestor_data;
uint32_t first;
uint32_t last;
char seq_filename[PATH_MAX];
struct nntp_cached_session_state_data * cached_data;
int r;
first = 0;
last = 0;
cached_data = get_cached_data(session);
ancestor_data = get_ancestor_data(session);
if (ancestor_data->nntp_group_name == NULL)
return;
snprintf(seq_filename, PATH_MAX, "%s/%s/%s",
cached_data->nntp_cache_directory,
ancestor_data->nntp_group_name, SEQ_FILENAME);
f = fopen(seq_filename, "r");
if (f != NULL) {
int fd;
fd = fileno(f);
r = maillock_read_lock(seq_filename, fd);
if (r == 0) {
MMAPString * mmapstr;
size_t cur_token;
char buf[sizeof(uint32_t) * 2];
size_t read_size;
read_size = fread(buf, 1, sizeof(uint32_t) * 2, f);
mmapstr = mmap_string_new_len(buf, read_size);
if (mmapstr != NULL) {
cur_token = 0;
r = mailimf_cache_int_read(mmapstr, &cur_token, &first);
r = mailimf_cache_int_read(mmapstr, &cur_token, &last);
mmap_string_free(mmapstr);
}
maillock_read_unlock(seq_filename, fd);
}
fclose(f);
}
* pfirst = first;
* plast = last;
}
static int pop3driver_cached_logout(mailsession * session)
{
struct pop3_cached_session_state_data * cached_data;
cached_data = get_cached_data(session);
pop3_flags_store_process(cached_data->pop3_flags_directory,
cached_data->pop3_flags_store);
return mailsession_logout(get_ancestor(session));
}
static int pop3driver_cached_check_folder(mailsession * session)
{
struct pop3_cached_session_state_data * pop3_data;
pop3_data = get_cached_data(session);
pop3_flags_store_process(pop3_data->pop3_flags_directory,
pop3_data->pop3_flags_store);
return MAIL_NO_ERROR;
}
static int mhdriver_cached_check_folder(mailsession * session)
{
struct mh_cached_session_state_data * cached_data;
cached_data = get_cached_data(session);
mh_flags_store_process(cached_data->mh_flags_directory,
cached_data->mh_quoted_mb,
cached_data->mh_flags_store);
return MAIL_NO_ERROR;
}
static void write_article_seq(mailsession * session,
uint32_t first, uint32_t last)
{
FILE * f;
struct nntp_session_state_data * ancestor_data;
char seq_filename[PATH_MAX];
struct nntp_cached_session_state_data * cached_data;
int r;
int fd;
cached_data = get_cached_data(session);
ancestor_data = get_ancestor_data(session);
if (ancestor_data->nntp_group_name == NULL)
return;
snprintf(seq_filename, PATH_MAX, "%s/%s/%s",
cached_data->nntp_cache_directory,
ancestor_data->nntp_group_name, SEQ_FILENAME);
fd = creat(seq_filename, S_IRUSR | S_IWUSR);
if (fd < 0)
return;
f = fdopen(fd, "w");
if (f != NULL) {
r = maillock_write_lock(seq_filename, fd);
if (r == 0) {
MMAPString * mmapstr;
size_t cur_token;
mmapstr = mmap_string_new("");
if (mmapstr != NULL) {
r = mail_serialize_clear(mmapstr, &cur_token);
if (r == MAIL_NO_ERROR) {
r = mailimf_cache_int_write(mmapstr, &cur_token, first);
r = mailimf_cache_int_write(mmapstr, &cur_token, last);
fwrite(mmapstr->str, 1, mmapstr->len, f);
}
mmap_string_free(mmapstr);
}
r = maillock_write_unlock(seq_filename, fd);
}
fclose(f);
}
else
close(fd);
}
static int nntpdriver_cached_check_folder(mailsession * session)
{
struct nntp_session_state_data * ancestor_data;
struct nntp_cached_session_state_data * cached_data;
cached_data = get_cached_data(session);
ancestor_data = get_ancestor_data(session);
nntp_flags_store_process(cached_data->nntp_flags_directory,
ancestor_data->nntp_group_name,
cached_data->nntp_flags_store);
return MAIL_NO_ERROR;
}
static int nntpdriver_cached_logout(mailsession * session)
{
struct nntp_cached_session_state_data * cached_data;
struct nntp_session_state_data * ancestor_data;
cached_data = get_cached_data(session);
ancestor_data = get_ancestor_data(session);
nntp_flags_store_process(cached_data->nntp_flags_directory,
ancestor_data->nntp_group_name,
cached_data->nntp_flags_store);
return mailsession_logout(get_ancestor(session));
}
static int mhdriver_cached_logout(mailsession * session)
{
int r;
struct mh_cached_session_state_data * cached_data;
r = write_max_uid_value(session);
cached_data = get_cached_data(session);
mh_flags_store_process(cached_data->mh_flags_directory,
cached_data->mh_quoted_mb,
cached_data->mh_flags_store);
return mailsession_logout(get_ancestor(session));
}
static void pop3driver_cached_uninitialize(mailsession * session)
{
struct pop3_cached_session_state_data * data;
data = get_cached_data(session);
pop3_flags_store_process(data->pop3_flags_directory,
data->pop3_flags_store);
mail_flags_store_free(data->pop3_flags_store);
chash_free(data->pop3_flags_hash);
mailsession_free(data->pop3_ancestor);
free(data);
session->sess_data = NULL;
}
static void mhdriver_cached_uninitialize(mailsession * session)
{
struct mh_cached_session_state_data * data;
data = get_cached_data(session);
mh_flags_store_process(data->mh_flags_directory, data->mh_quoted_mb,
data->mh_flags_store);
mail_flags_store_free(data->mh_flags_store);
free_state(data);
mailsession_free(data->mh_ancestor);
free(data);
session->sess_data = NULL;
}
static int nntpdriver_cached_select_folder(mailsession * session, const char * mb)
{
int r;
struct nntp_session_state_data * ancestor_data;
struct nntp_cached_session_state_data * cached_data;
int res;
char key[PATH_MAX];
cached_data = get_cached_data(session);
ancestor_data = get_ancestor_data(session);
nntp_flags_store_process(cached_data->nntp_flags_directory,
ancestor_data->nntp_group_name,
cached_data->nntp_flags_store);
r = mailsession_select_folder(get_ancestor(session), mb);
if (r != MAIL_NO_ERROR)
return r;
if (ancestor_data->nntp_group_name == NULL)
return MAIL_ERROR_BAD_STATE;
snprintf(key, PATH_MAX, "%s/%s", cached_data->nntp_cache_directory,
ancestor_data->nntp_group_name);
r = generic_cache_create_dir(key);
if (r != MAIL_NO_ERROR) {
res = r;
goto err;
}
snprintf(key, PATH_MAX, "%s/%s", cached_data->nntp_flags_directory,
ancestor_data->nntp_group_name);
r = generic_cache_create_dir(key);
if (r != MAIL_NO_ERROR) {
res = r;
goto err;
}
return MAIL_NO_ERROR;
err:
return res;
}
static int get_cache_directory(mailsession * session,
const char * path, char ** result)
{
char * quoted_mb;
char dirname[PATH_MAX];
int res;
int r;
struct mh_cached_session_state_data * cached_data;
cached_data = get_cached_data(session);
quoted_mb = maildriver_quote_mailbox(path);
if (quoted_mb == NULL) {
res = MAIL_ERROR_MEMORY;
goto err;
}
snprintf(dirname, PATH_MAX, "%s/%s",
cached_data->mh_cache_directory, quoted_mb);
r = generic_cache_create_dir(dirname);
if (r != MAIL_NO_ERROR) {
res = r;
goto free;
}
snprintf(dirname, PATH_MAX, "%s/%s",
cached_data->mh_flags_directory, quoted_mb);
r = generic_cache_create_dir(dirname);
if (r != MAIL_NO_ERROR) {
res = r;
goto free;
}
* result = quoted_mb;
return MAIL_NO_ERROR;
free:
free(quoted_mb);
err:
return res;
}
static void nntpdriver_cached_uninitialize(mailsession * session)
{
struct nntp_cached_session_state_data * cached_data;
struct nntp_session_state_data * ancestor_data;
cached_data = get_cached_data(session);
ancestor_data = get_ancestor_data(session);
nntp_flags_store_process(cached_data->nntp_flags_directory,
ancestor_data->nntp_group_name,
cached_data->nntp_flags_store);
mail_flags_store_free(cached_data->nntp_flags_store);
mailsession_free(cached_data->nntp_ancestor);
free(cached_data);
session->sess_data = NULL;
}
static int mhdriver_cached_select_folder(mailsession * session, const char * mb)
{
int r;
int res;
char * quoted_mb;
struct mh_cached_session_state_data * cached_data;
cached_data = get_cached_data(session);
mh_flags_store_process(cached_data->mh_flags_directory,
cached_data->mh_quoted_mb,
cached_data->mh_flags_store);
quoted_mb = NULL;
r = get_cache_directory(session, mb, "ed_mb);
if (r != MAIL_NO_ERROR) {
res = r;
goto err;
}
r = mailsession_select_folder(get_ancestor(session), mb);
if (r != MAIL_NO_ERROR) {
res = r;
goto free;
}
r = write_max_uid_value(session);
free_state(cached_data);
cached_data->mh_quoted_mb = quoted_mb;
r = read_max_uid_value(session);
return MAIL_NO_ERROR;
free:
free(quoted_mb);
err:
return res;
}
static int mhdriver_cached_expunge_folder(mailsession * session)
{
struct mailmh_folder * folder;
int res;
char filename_flags[PATH_MAX];
struct mail_cache_db * cache_db_flags;
MMAPString * mmapstr;
struct mh_cached_session_state_data * cached_data;
unsigned int i;
int r;
cached_data = get_cached_data(session);
if (cached_data->mh_quoted_mb == NULL) {
res = MAIL_ERROR_BAD_STATE;
goto err;
}
mh_flags_store_process(cached_data->mh_flags_directory,
cached_data->mh_quoted_mb,
cached_data->mh_flags_store);
folder = get_mh_cur_folder(session);
if (folder == NULL) {
res = MAIL_ERROR_BAD_STATE;
goto err;
}
snprintf(filename_flags, PATH_MAX, "%s/%s/%s",
cached_data->mh_flags_directory, cached_data->mh_quoted_mb, FLAGS_NAME);
r = mail_cache_db_open_lock(filename_flags, &cache_db_flags);
if (r < 0) {
res = MAIL_ERROR_FILE;
goto err;
}
mmapstr = mmap_string_new("");
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto close_db_flags;
}
for(i = 0 ; i < carray_count(folder->fl_msgs_tab) ; i++) {
struct mailmh_msg_info * mh_info;
struct mail_flags * flags;
mh_info = carray_get(folder->fl_msgs_tab, i);
if (mh_info == NULL)
continue;
r = mhdriver_get_cached_flags(cache_db_flags, mmapstr,
session, mh_info->msg_index, &flags);
if (r != MAIL_NO_ERROR)
continue;
if (flags->fl_flags & MAIL_FLAG_DELETED) {
r = mailmh_folder_remove_message(folder, mh_info->msg_index);
}
mail_flags_free(flags);
}
mmap_string_free(mmapstr);
mail_cache_db_close_unlock(filename_flags, cache_db_flags);
mailmh_folder_update(folder);
return MAIL_NO_ERROR;
close_db_flags:
mail_cache_db_close_unlock(filename_flags, cache_db_flags);
err:
return res;
}
static int pop3driver_cached_status_folder(mailsession * session,
const char * mb, uint32_t * result_messages, uint32_t * result_recent,
uint32_t * result_unseen)
{
int res;
struct pop3_cached_session_state_data * cached_data;
char filename_flags[PATH_MAX];
struct mail_cache_db * cache_db_flags;
MMAPString * mmapstr;
unsigned int i;
int r;
carray * msg_tab;
mailpop3 * pop3;
uint32_t recent;
uint32_t unseen;
recent = 0;
unseen = 0;
pop3 = get_pop3_session(session);
cached_data = get_cached_data(session);
pop3_flags_store_process(cached_data->pop3_flags_directory,
cached_data->pop3_flags_store);
snprintf(filename_flags, PATH_MAX, "%s/%s",
cached_data->pop3_flags_directory, FLAGS_NAME);
r = mail_cache_db_open_lock(filename_flags, &cache_db_flags);
if (r < 0) {
res = MAIL_ERROR_FILE;
goto err;
}
mmapstr = mmap_string_new("");
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto close_db_flags;
}
r = mailpop3_list(pop3, &msg_tab);
if (r != MAILPOP3_NO_ERROR) {
res = pop3driver_pop3_error_to_mail_error(r);
goto free_mmapstr;
}
for(i = 0 ; i < carray_count(msg_tab) ; i++) {
struct mailpop3_msg_info * pop3_info;
struct mail_flags * flags;
pop3_info = carray_get(msg_tab, i);
if (pop3_info == NULL)
continue;
if (pop3_info->msg_deleted)
continue;
r = pop3driver_get_cached_flags(cache_db_flags, mmapstr,
session, pop3_info->msg_index, &flags);
if (r != MAIL_NO_ERROR) {
recent ++;
unseen ++;
continue;
}
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);
mail_cache_db_close_unlock(filename_flags, cache_db_flags);
* result_messages = carray_count(msg_tab) - pop3->pop3_deleted_count;
* result_recent = recent;
* result_unseen = unseen;
return MAIL_NO_ERROR;
free_mmapstr:
mmap_string_free(mmapstr);
close_db_flags:
mail_cache_db_close_unlock(filename_flags, cache_db_flags);
err:
return res;
}
static int nntpdriver_cached_status_folder(mailsession * session,
const char * mb, uint32_t * result_messages, uint32_t * result_recent,
uint32_t * result_unseen)
{
int res;
struct nntp_cached_session_state_data * cached_data;
struct nntp_session_state_data * ancestor_data;
char filename_flags[PATH_MAX];
struct mail_cache_db * cache_db_flags;
MMAPString * mmapstr;
uint32_t i;
int r;
uint32_t recent;
uint32_t unseen;
uint32_t first;
uint32_t last;
uint32_t count;
uint32_t additionnal;
r = nntpdriver_cached_select_folder(session, mb);
if (r != MAIL_NO_ERROR) {
res = r;
goto err;
}
read_article_seq(session, &first, &last);
count = 0;
recent = 0;
unseen = 0;
ancestor_data = get_ancestor_data(session);
cached_data = get_cached_data(session);
if (ancestor_data->nntp_group_name == NULL) {
res = MAIL_ERROR_BAD_STATE;
goto err;
}
if (ancestor_data->nntp_group_info->grp_first > first)
first = ancestor_data->nntp_group_info->grp_first;
if (last < first)
last = ancestor_data->nntp_group_info->grp_last;
snprintf(filename_flags, PATH_MAX, "%s/%s/%s",
cached_data->nntp_flags_directory,
ancestor_data->nntp_group_name, FLAGS_NAME);
r = mail_cache_db_open_lock(filename_flags, &cache_db_flags);
if (r < 0) {
res = MAIL_ERROR_FILE;
goto err;
}
mmapstr = mmap_string_new("");
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto close_db_flags;
}
for(i = first ; i <= last ; i++) {
struct mail_flags * flags;
r = nntpdriver_get_cached_flags(cache_db_flags, mmapstr,
i, &flags);
if (r == MAIL_NO_ERROR) {
if ((flags->fl_flags & MAIL_FLAG_CANCELLED) != 0) {
mail_flags_free(flags);
continue;
}
count ++;
if ((flags->fl_flags & MAIL_FLAG_NEW) != 0) {
recent ++;
}
if ((flags->fl_flags & MAIL_FLAG_SEEN) == 0) {
unseen ++;
}
mail_flags_free(flags);
}
}
if ((count == 0) && (first != last)) {
count = last - first + 1;
recent = count;
unseen = count;
}
additionnal = ancestor_data->nntp_group_info->grp_last - last;
recent += additionnal;
unseen += additionnal;
mmap_string_free(mmapstr);
mail_cache_db_close_unlock(filename_flags, cache_db_flags);
* result_messages = count;
* result_recent = recent;
* result_unseen = unseen;
return MAIL_NO_ERROR;
close_db_flags:
mail_cache_db_close_unlock(filename_flags, cache_db_flags);
err:
return res;
}
static int write_max_uid_value(mailsession * session)
{
int r;
char filename[PATH_MAX];
FILE * f;
int res;
struct mh_cached_session_state_data * cached_data;
struct mh_session_state_data * ancestor_data;
int fd;
MMAPString * mmapstr;
size_t cur_token;
cached_data = get_cached_data(session);
ancestor_data = get_ancestor_data(session);
if (cached_data->mh_quoted_mb == NULL)
return MAIL_ERROR_BAD_STATE;
snprintf(filename, PATH_MAX, "%s/%s/%s",
cached_data->mh_cache_directory,
cached_data->mh_quoted_mb, FILENAME_MAX_UID);
fd = creat(filename, S_IRUSR | S_IWUSR);
if (fd < 0) {
res = MAIL_ERROR_FILE;
goto err;
}
f = fdopen(fd, "w");
if (f == NULL) {
close(fd);
res = MAIL_ERROR_FILE;
goto err;
}
mmapstr = mmap_string_new("");
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto close;
}
r = mail_serialize_clear(mmapstr, &cur_token);
if (r != MAIL_NO_ERROR) {
res = r;
goto free_mmapstr;
}
r = mailimf_cache_int_write(mmapstr, &cur_token,
ancestor_data->mh_cur_folder->fl_max_index);
if (r != MAIL_NO_ERROR) {
res = r;
goto free_mmapstr;
}
r = fwrite(mmapstr->str, 1, mmapstr->len, f);
if ((size_t) r != mmapstr->len) {
res = MAIL_ERROR_FILE;
goto free_mmapstr;
}
mmap_string_free(mmapstr);
fclose(f);
return MAIL_NO_ERROR;
free_mmapstr:
mmap_string_free(mmapstr);
close:
fclose(f);
err:
return res;
}
static inline mailsession * get_ancestor(mailsession * session)
{
return get_cached_data(session)->mh_ancestor;
}
static int
mhdriver_cached_get_envelopes_list(mailsession * session,
struct mailmessage_list * env_list)
{
int r;
unsigned int i;
char filename_env[PATH_MAX];
char filename_flags[PATH_MAX];
struct mail_cache_db * cache_db_env;
struct mail_cache_db * cache_db_flags;
MMAPString * mmapstr;
int res;
struct mh_cached_session_state_data * cached_data;
cached_data = get_cached_data(session);
if (cached_data->mh_quoted_mb == NULL) {
res = MAIL_ERROR_BAD_STATE;
goto err;
}
mh_flags_store_process(cached_data->mh_flags_directory,
cached_data->mh_quoted_mb,
cached_data->mh_flags_store);
mmapstr = mmap_string_new("");
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto err;
}
snprintf(filename_env, PATH_MAX, "%s/%s/%s",
cached_data->mh_cache_directory,
cached_data->mh_quoted_mb, ENV_NAME);
r = mail_cache_db_open_lock(filename_env, &cache_db_env);
if (r < 0) {
res = MAIL_ERROR_FILE;
goto free_mmapstr;
}
snprintf(filename_flags, PATH_MAX, "%s/%s/%s",
cached_data->mh_flags_directory, cached_data->mh_quoted_mb, FLAGS_NAME);
r = mail_cache_db_open_lock(filename_flags, &cache_db_flags);
if (r < 0) {
res = MAIL_ERROR_FILE;
goto close_db_env;
}
/* fill with cached */
for(i = 0 ; i < carray_count(env_list->msg_tab) ; i ++) {
mailmessage * msg;
struct mailimf_fields * fields;
struct mail_flags * flags;
msg = carray_get(env_list->msg_tab, i);
if (msg->msg_fields == NULL) {
r = get_cached_envelope(cache_db_env, mmapstr,
msg->msg_session, msg->msg_index, &fields);
if (r == MAIL_NO_ERROR) {
msg->msg_cached = TRUE;
msg->msg_fields = fields;
}
}
if (msg->msg_flags == NULL) {
r = mhdriver_get_cached_flags(cache_db_flags, mmapstr,
session, msg->msg_index, &flags);
if (r == MAIL_NO_ERROR) {
msg->msg_flags = flags;
}
}
}
mail_cache_db_close_unlock(filename_flags, cache_db_flags);
mail_cache_db_close_unlock(filename_env, cache_db_env);
r = mailsession_get_envelopes_list(get_ancestor(session), env_list);
if (r != MAIL_NO_ERROR) {
res = r;
goto free_mmapstr;
}
r = mail_cache_db_open_lock(filename_env, &cache_db_env);
if (r < 0) {
res = MAIL_ERROR_FILE;
goto free_mmapstr;
}
r = mail_cache_db_open_lock(filename_flags, &cache_db_flags);
if (r < 0) {
res = MAIL_ERROR_FILE;
goto close_db_env;
}
/* add flags */
for(i = 0 ; i < carray_count(env_list->msg_tab) ; i ++) {
mailmessage * msg;
msg = carray_get(env_list->msg_tab, i);
if (msg->msg_flags == NULL)
msg->msg_flags = mail_flags_new_empty();
}
/* must write cache */
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) {
if (!msg->msg_cached) {
r = write_cached_envelope(cache_db_env, mmapstr,
session, msg->msg_index, msg->msg_fields);
}
}
if (msg->msg_flags != NULL) {
r = mhdriver_write_cached_flags(cache_db_flags, mmapstr,
msg->msg_uid, msg->msg_flags);
}
}
/* flush cache */
maildriver_cache_clean_up(cache_db_env, cache_db_flags, env_list);
mail_cache_db_close_unlock(filename_flags, cache_db_flags);
mail_cache_db_close_unlock(filename_env, cache_db_env);
mmap_string_free(mmapstr);
return MAIL_NO_ERROR;
close_db_env:
mail_cache_db_close_unlock(filename_env, cache_db_env);
free_mmapstr:
mmap_string_free(mmapstr);
err:
return res;
}
static int mhdriver_cached_status_folder(mailsession * session, const char * mb,
uint32_t * result_messages,
uint32_t * result_recent,
uint32_t * result_unseen)
{
struct mailmh_folder * folder;
int res;
char filename_flags[PATH_MAX];
struct mail_cache_db * cache_db_flags;
MMAPString * mmapstr;
struct mh_cached_session_state_data * cached_data;
unsigned int i;
int r;
uint32_t count;
uint32_t recent;
uint32_t unseen;
r = mhdriver_cached_select_folder(session, mb);
if (r != MAIL_NO_ERROR) {
res = r;
goto err;
}
count = 0;
recent = 0;
unseen = 0;
folder = get_mh_cur_folder(session);
if (folder == NULL) {
res = MAIL_ERROR_BAD_STATE;
goto err;
}
cached_data = get_cached_data(session);
if (cached_data->mh_quoted_mb == NULL) {
res = MAIL_ERROR_BAD_STATE;
goto err;
}
snprintf(filename_flags, PATH_MAX, "%s/%s/%s",
cached_data->mh_flags_directory,
cached_data->mh_quoted_mb, FLAGS_NAME);
r = mail_cache_db_open_lock(filename_flags, &cache_db_flags);
if (r < 0) {
res = MAIL_ERROR_FILE;
goto err;
}
mmapstr = mmap_string_new("");
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto close_db_flags;
}
for(i = 0 ; i < carray_count(folder->fl_msgs_tab) ; i++) {
struct mailmh_msg_info * mh_info;
struct mail_flags * flags;
mh_info = carray_get(folder->fl_msgs_tab, i);
if (mh_info == NULL)
continue;
count ++;
r = mhdriver_get_cached_flags(cache_db_flags, mmapstr,
session, mh_info->msg_index,
&flags);
if (r != MAIL_NO_ERROR) {
recent ++;
unseen ++;
continue;
}
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);
mail_cache_db_close_unlock(filename_flags, cache_db_flags);
* result_messages = count;
* result_recent = recent;
* result_unseen = unseen;
return MAIL_NO_ERROR;
close_db_flags:
mail_cache_db_close_unlock(filename_flags, cache_db_flags);
err:
return res;
}
static int mhdriver_cached_append_message_flags(mailsession * session,
const char * message, size_t size, struct mail_flags * flags)
{
int r;
struct mailmh_folder * folder;
struct mailmh_msg_info * msg_info;
chashdatum key;
chashdatum value;
uint32_t uid;
struct mh_cached_session_state_data * data;
char filename_flags[PATH_MAX];
struct mail_cache_db * cache_db_flags;
MMAPString * mmapstr;
char keyname[PATH_MAX];
folder = get_mh_cur_folder(session);
if (folder == NULL)
return MAIL_ERROR_BAD_STATE;
r = mailmh_folder_add_message_uid(folder,
message, size, &uid);
switch (r) {
case MAILMH_ERROR_FILE:
return MAIL_ERROR_DISKSPACE;
case MAILMH_NO_ERROR:
break;
default:
return mhdriver_mh_error_to_mail_error(r);
}
if (flags == NULL)
goto exit;
key.data = &uid;
key.len = sizeof(uid);
r = chash_get(folder->fl_msgs_hash, &key, &value);
if (r < 0)
return MAIL_ERROR_CACHE_MISS;
msg_info = value.data;
data = get_cached_data(session);
snprintf(filename_flags, PATH_MAX, "%s/%s/%s",
data->mh_flags_directory, data->mh_quoted_mb, FLAGS_NAME);
r = mail_cache_db_open_lock(filename_flags, &cache_db_flags);
if (r < 0)
goto exit;
mmapstr = mmap_string_new("");
if (mmapstr == NULL)
goto close_db_flags;
snprintf(keyname, PATH_MAX, "%u-%lu-%lu-flags",
uid, (unsigned long) msg_info->msg_mtime,
(unsigned long) msg_info->msg_size);
r = mhdriver_write_cached_flags(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)
goto exit;
return MAIL_NO_ERROR;
close_db_flags:
mail_cache_db_close_unlock(filename_flags, cache_db_flags);
exit:
return MAIL_NO_ERROR;
}
static int
nntpdriver_cached_get_envelopes_list(mailsession * session,
struct mailmessage_list * env_list)
{
int r;
unsigned int i;
struct nntp_cached_session_state_data * cached_data;
uint32_t first;
uint32_t last;
struct nntp_session_state_data * ancestor_data;
char filename_env[PATH_MAX];
char filename_flags[PATH_MAX];
struct mail_cache_db * cache_db_env;
struct mail_cache_db * cache_db_flags;
MMAPString * mmapstr;
int res;
char cache_dir[PATH_MAX];
cached_data = get_cached_data(session);
ancestor_data = get_ancestor_data(session);
nntp_flags_store_process(cached_data->nntp_flags_directory,
ancestor_data->nntp_group_name,
cached_data->nntp_flags_store);
if (ancestor_data->nntp_group_name == NULL) {
res = MAIL_ERROR_BAD_STATE;
goto err;
}
/* read articles sequence */
read_article_seq(session, &first, &last);
mmapstr = mmap_string_new("");
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto err;
}
snprintf(filename_env, PATH_MAX, "%s/%s/%s",
cached_data->nntp_cache_directory,
ancestor_data->nntp_group_name, ENV_NAME);
r = mail_cache_db_open_lock(filename_env, &cache_db_env);
if (r < 0) {
res = MAIL_ERROR_FILE;
goto free_mmapstr;
}
snprintf(filename_flags, PATH_MAX, "%s/%s/%s",
cached_data->nntp_flags_directory,
ancestor_data->nntp_group_name, FLAGS_NAME);
/* fill with cached */
for(i = 0 ; i < carray_count(env_list->msg_tab) ; i ++) {
mailmessage * msg;
struct mailimf_fields * fields;
msg = carray_get(env_list->msg_tab, i);
if ((msg->msg_index < first) || (msg->msg_index > last))
continue;
if (msg->msg_fields == NULL) {
r = get_cached_envelope(cache_db_env, mmapstr,
session, msg->msg_index, &fields);
if (r == MAIL_NO_ERROR) {
msg->msg_fields = fields;
msg->msg_cached = TRUE;
}
}
}
mail_cache_db_close_unlock(filename_env, cache_db_env);
r = mailsession_get_envelopes_list(get_ancestor(session), env_list);
if (r != MAIL_NO_ERROR) {
res = r;
goto free_mmapstr;
}
r = mail_cache_db_open_lock(filename_flags, &cache_db_flags);
if (r < 0) {
res = MAIL_ERROR_FILE;
goto free_mmapstr;
}
/* add flags */
for(i = 0 ; i < carray_count(env_list->msg_tab) ; i ++) {
mailmessage * msg;
msg = carray_get(env_list->msg_tab, i);
if (msg->msg_flags == NULL) {
struct mail_flags * flags;
r = nntpdriver_get_cached_flags(cache_db_flags, mmapstr,
msg->msg_index, &flags);
if (r == MAIL_NO_ERROR) {
msg->msg_flags = flags;
}
else {
msg->msg_flags = mail_flags_new_empty();
if (msg->msg_fields == NULL) {
msg->msg_flags->fl_flags |= MAIL_FLAG_CANCELLED;
mailmessage_check(msg);
}
}
}
}
mail_cache_db_close_unlock(filename_flags, cache_db_flags);
r = mail_cache_db_open_lock(filename_env, &cache_db_env);
if (r < 0) {
res = MAIL_ERROR_FILE;
goto free_mmapstr;
}
r = mail_cache_db_open_lock(filename_flags, &cache_db_flags);
if (r < 0) {
res = MAIL_ERROR_FILE;
goto close_db_env;
}
/* must write cache */
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) {
if (!msg->msg_cached) {
r = write_cached_envelope(cache_db_env, mmapstr,
session, msg->msg_index, msg->msg_fields);
}
}
if (msg->msg_flags != NULL) {
r = nntpdriver_write_cached_flags(cache_db_flags, mmapstr,
msg->msg_index, msg->msg_flags);
}
}
first = 0;
last = 0;
if (carray_count(env_list->msg_tab) > 0) {
mailmessage * msg;
msg = carray_get(env_list->msg_tab, 0);
first = msg->msg_index;
msg = carray_get(env_list->msg_tab, carray_count(env_list->msg_tab) - 1);
last = msg->msg_index;
}
/* write articles sequence */
write_article_seq(session, first, last);
/* flush cache */
maildriver_cache_clean_up(cache_db_env, cache_db_flags, env_list);
/* remove cache files */
snprintf(cache_dir, PATH_MAX, "%s/%s",
cached_data->nntp_cache_directory, ancestor_data->nntp_group_name);
mail_cache_db_close_unlock(filename_flags, cache_db_flags);
mail_cache_db_close_unlock(filename_env, cache_db_env);
mmap_string_free(mmapstr);
maildriver_message_cache_clean_up(cache_dir, env_list,
get_uid_from_filename);
return MAIL_NO_ERROR;
close_db_env:
mail_cache_db_close_unlock(filename_env, cache_db_env);
free_mmapstr:
mmap_string_free(mmapstr);
err:
return res;
}
