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