int
mailmessage_generic_fetch_section(mailmessage * msg_info,
struct mailmime * mime,
char ** result, size_t * result_len)
{
MMAPString * mmapstr;
int r;
int res;
mmapstr = mmap_string_new_len(mime->mm_body->dt_data.dt_text.dt_data,
mime->mm_body->dt_data.dt_text.dt_length);
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto err;
}
r = mmap_string_ref(mmapstr);
if (r < 0) {
res = MAIL_ERROR_MEMORY;
goto free_mmap;
}
* result = mmapstr->str;
* result_len = mmapstr->len;
return MAIL_NO_ERROR;
free_mmap:
mmap_string_free(mmapstr);
err:
return res;
}
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 prefetch(mailmessage * msg_info)
{
struct generic_message_t * msg;
int res;
struct db_msg_data * data;
struct db_session_state_data * sess_data;
MMAPString * msg_content;
struct mail_cache_db * maildb;
int r;
char key[PATH_MAX];
void * msg_data;
size_t msg_data_len;
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", (unsigned long) msg_info->msg_index);
r = mail_cache_db_get(maildb, key, strlen(key), &msg_data, &msg_data_len);
if (r < 0) {
res = MAIL_ERROR_MSG_NOT_FOUND;
goto close_db;
}
msg_content = mmap_string_new_len(msg_data, msg_data_len);
if (msg_content == NULL) {
res = MAIL_ERROR_MEMORY;
goto close_db;
}
data = malloc(sizeof(* data));
if (data == NULL) {
res = MAIL_ERROR_MEMORY;
goto free_mmapstr;
}
data->msg_content = msg_content;
msg = msg_info->msg_data;
msg->msg_data = data;
msg->msg_message = msg_content->str;
msg->msg_length = msg_content->len;
mail_cache_db_close_unlock(sess_data->db_filename, maildb);
return MAIL_NO_ERROR;
free_mmapstr:
mmap_string_free(msg_content);
close_db:
mail_cache_db_close_unlock(sess_data->db_filename, maildb);
err:
return res;
}
int
mailmessage_generic_fetch_section_body(mailmessage * msg_info,
struct mailmime * mime,
char ** result,
size_t * result_len)
{
MMAPString * mmapstr;
int r;
int res;
size_t cur_token;
cur_token = 0;
if (mime->mm_type == MAILMIME_MESSAGE) {
/* skip header */
while (1) {
r = mailimf_ignore_field_parse(mime->mm_body->dt_data.dt_text.dt_data,
mime->mm_body->dt_data.dt_text.dt_length, &cur_token);
if (r == MAILIMF_NO_ERROR) {
/* do nothing */
}
else
break;
}
r = mailimf_crlf_parse(mime->mm_body->dt_data.dt_text.dt_data,
mime->mm_body->dt_data.dt_text.dt_length, &cur_token);
if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
res = maildriver_imf_error_to_mail_error(r);
goto err;
}
}
mmapstr = mmap_string_new_len(mime->mm_body->dt_data.dt_text.dt_data +
cur_token, mime->mm_body->dt_data.dt_text.dt_length - cur_token);
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto err;
}
r = mmap_string_ref(mmapstr);
if (r < 0) {
res = MAIL_ERROR_MEMORY;
goto free_mmap;
}
* result = mmapstr->str;
* result_len = mmapstr->len;
return MAIL_NO_ERROR;
free_mmap:
mmap_string_free(mmapstr);
err:
return res;
}
int mailmessage_generic_fetch_header(mailmessage * msg_info,
char ** result,
size_t * result_len)
{
int r;
char * message;
size_t cur_token;
size_t length;
MMAPString * mmapstr;
char * headers;
int res;
struct generic_message_t * msg;
msg = msg_info->msg_data;
r = mailmessage_generic_prefetch(msg_info);
if (r != MAIL_NO_ERROR) {
res = r;
goto err;
}
message = msg->msg_message;
length = msg->msg_length;
cur_token = 0;
while (1) {
r = mailimf_ignore_field_parse(message, length, &cur_token);
if (r == MAILIMF_NO_ERROR) {
/* do nothing */
}
else
break;
}
mailimf_crlf_parse(message, length, &cur_token);
mmapstr = mmap_string_new_len(message, cur_token);
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto err;
}
r = mmap_string_ref(mmapstr);
if (r < 0) {
res = MAIL_ERROR_MEMORY;
goto free_mmap;
}
headers = mmapstr->str;
* result = headers;
* result_len = cur_token;
return MAIL_NO_ERROR;
free_mmap:
mmap_string_free(mmapstr);
err:
return res;
}
int generic_cache_read(char * filename, char ** result, size_t * result_len)
{
int fd;
char * str;
struct stat buf;
MMAPString * mmapstr;
char * content;
int res;
if (stat(filename, &buf) < 0) {
res = MAIL_ERROR_CACHE_MISS;
goto err;
}
fd = open(filename, O_RDONLY);
if (fd == -1) {
res = MAIL_ERROR_CACHE_MISS;
goto err;
}
str = mmap(NULL, buf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
if (str == (char *)MAP_FAILED) {
res = MAIL_ERROR_FILE;
goto close;
}
mmapstr = mmap_string_new_len(str, buf.st_size);
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto unmap;
}
if (mmap_string_ref(mmapstr) < 0) {
res = MAIL_ERROR_MEMORY;
goto free;
}
content = mmapstr->str;
munmap(str, buf.st_size);
close(fd);
* result = content;
* result_len = buf.st_size;
return MAIL_NO_ERROR;
free:
mmap_string_free(mmapstr);
unmap:
munmap(str, buf.st_size);
close:
close(fd);
err:
return res;
}
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 body_to_mmapstr(char * data, size_t size,
char ** result, size_t * result_len)
{
MMAPString * mmapstr;
size_t cur_token;
int res;
int r;
cur_token = 0;
/* skip header */
while (1) {
r = mailimf_ignore_field_parse(data, size, &cur_token);
if (r == MAILIMF_NO_ERROR) {
/* do nothing */
}
else
break;
}
r = mailimf_crlf_parse(data, size, &cur_token);
if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
res = maildriver_imf_error_to_mail_error(r);
goto err;
}
mmapstr = mmap_string_new_len(data + cur_token, size - cur_token);
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto err;
}
r = mmap_string_ref(mmapstr);
if (r != 0) {
mmap_string_free(mmapstr);
res = MAIL_ERROR_MEMORY;
goto err;
}
* result = mmapstr->str;
* result_len = mmapstr->len;
return MAIL_NO_ERROR;
err:
return res;
}
int mailmessage_generic_fetch(mailmessage * msg_info,
char ** result,
size_t * result_len)
{
int r;
char * message;
size_t length;
MMAPString * mmapstr;
int res;
struct generic_message_t * msg;
msg = msg_info->msg_data;
r = mailmessage_generic_prefetch(msg_info);
if (r != MAIL_NO_ERROR) {
res = r;
goto err;
}
message = msg->msg_message;
length = msg->msg_length;
mmapstr = mmap_string_new_len(message, length);
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto err;
}
r = mmap_string_ref(mmapstr);
if (r < 0) {
res = MAIL_ERROR_MEMORY;
goto free_mmap;
}
* result = mmapstr->str;
* result_len = length;
return MAIL_NO_ERROR;
free_mmap:
mmap_string_free(mmapstr);
err:
return res;
}
int mailmbox_fetch_msg_headers(struct mailmbox_folder * folder,
uint32_t num, char ** result,
size_t * result_len)
{
MMAPString * mmapstr;
int res;
char * data;
size_t len;
int r;
size_t fixed_size;
char * end;
r = mailmbox_validate_read_lock(folder);
if (r != MAILMBOX_NO_ERROR) {
res = r;
goto err;
}
r = mailmbox_fetch_msg_headers_no_lock(folder, num, &data, &len);
if (r != MAILMBOX_NO_ERROR) {
res = r;
goto unlock;
}
#if 0
mmapstr = mmap_string_new_len(data, len);
if (mmapstr == NULL) {
res = MAILMBOX_ERROR_MEMORY;
goto unlock;
}
#endif
/* size with no uid */
fixed_size = get_fixed_message_size(data, len, 0, 1 /* force no uid */);
mmapstr = mmap_string_sized_new(fixed_size);
if (mmapstr == NULL) {
res = MAILMBOX_ERROR_MEMORY;
goto unlock;
}
end = write_fixed_message(mmapstr->str, data, len, 0, 1 /* force no uid */);
* end = '\0';
mmapstr->len = fixed_size;
r = mmap_string_ref(mmapstr);
if (r < 0) {
mmap_string_free(mmapstr);
res = MAILMBOX_ERROR_MEMORY;
goto unlock;
}
* result = mmapstr->str;
* result_len = mmapstr->len;
mailmbox_read_unlock(folder);
return MAILMBOX_NO_ERROR;
unlock:
mailmbox_read_unlock(folder);
err:
return res;
}
static int db_get_message_list(struct mail_cache_db * maildb,
carray ** p_msglist)
{
carray * msglist;
void * serialized;
size_t serialized_len;
int r;
char key_value[PATH_MAX];
int res;
unsigned int i;
msglist = carray_new(16);
if (msglist == NULL) {
res = MAIL_ERROR_MEMORY;
goto err;
}
snprintf(key_value, sizeof(key_value), "message-list");
r = mail_cache_db_get(maildb, key_value, strlen(key_value),
&serialized, &serialized_len);
if (r >= 0) {
MMAPString * mmapstr;
size_t cur_token;
/* collect message list */
mmapstr = mmap_string_new_len(serialized, serialized_len);
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto free_msglist;
}
cur_token = 0;
do {
uint32_t num;
uint32_t * msg;
r = mailimf_cache_int_read(mmapstr, &cur_token, &num);
if (r != MAIL_NO_ERROR)
break;
msg = malloc(sizeof(* msg));
if (msg == NULL) {
res = MAIL_ERROR_MEMORY;
mmap_string_free(mmapstr);
goto free_msglist;
}
* msg = num;
r = carray_add(msglist, msg, NULL);
if (r < 0) {
res = MAIL_ERROR_MEMORY;
free(msg);
mmap_string_free(mmapstr);
goto free_msglist;
}
} while (1);
mmap_string_free(mmapstr);
}
* p_msglist = msglist;
return MAIL_NO_ERROR;
free_msglist:
for(i = 0 ; i < carray_count(msglist) ; i ++) {
uint32_t * msg;
msg = carray_get(msglist, i);
free(msg);
}
carray_free(msglist);
err:
return res;
}
