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;
}
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;
}
static int feed_prefetch(mailmessage * msg_info)
{
struct generic_message_t * msg;
int r;
MMAPString * str;
const char * text;
int col;
struct newsfeed * feed;
struct newsfeed_item * item;
int res;
feed = get_feed_session(msg_info);
item = newsfeed_get_item(feed, msg_info->msg_index);
str = mmap_string_new("");
if (str == NULL) {
res = MAIL_ERROR_MEMORY;
goto err;
}
col = 0;
r = mailimf_fields_write_mem(str, &col,
msg_info->msg_fields);
if (r != MAILIMF_NO_ERROR) {
res = MAIL_ERROR_MEMORY;
goto free_str;
}
if (mmap_string_append(str, "\r\n") == NULL) {
res = MAIL_ERROR_MEMORY;
goto free_str;
}
text = newsfeed_item_get_text(item);
if (text == NULL) {
/* if no content, fallback on summary */
text = newsfeed_item_get_summary(item);
}
if (mmap_string_append(str, text) == NULL) {
res = MAIL_ERROR_MEMORY;
goto free_str;
}
msg = msg_info->msg_data;
msg->msg_message = str->str;
msg->msg_length = str->len;
mmap_string_ref(str);
return MAIL_NO_ERROR;
free_str:
mmap_string_free(str);
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 int fetch_section(mailmessage * msg_info,
struct mailmime * mime,
char ** result, size_t * result_len)
{
int r;
int res;
int col;
MMAPString * str;
if (msg_info->msg_mime == NULL)
return MAIL_ERROR_INVAL;
str = mmap_string_new("");
if (str == NULL) {
res = MAILIMF_ERROR_MEMORY;
goto err;
}
col = 0;
r = mailmime_write_mem(str, &col, mime);
if (r != MAILIMF_NO_ERROR) {
res = maildriver_imf_error_to_mail_error(r);
goto free;
}
if (mime->mm_parent == NULL) {
r = mmap_string_ref(str);
if (r < 0) {
res = MAIL_ERROR_MEMORY;
goto free;
}
* result = str->str;
* result_len = str->len;
r = MAIL_NO_ERROR;
}
else {
r = body_to_mmapstr(str->str, str->len, result, result_len);
if (r == MAIL_NO_ERROR) {
mmap_string_free(str);
}
}
if (r != MAIL_NO_ERROR) {
res = r;
goto free;
}
return MAIL_NO_ERROR;
free:
mmap_string_free(str);
err:
return res;
}
static int fetch_section_mime(mailmessage * msg_info,
struct mailmime * mime,
char ** result, size_t * result_len)
{
int r;
int res;
int col;
MMAPString * str;
if (msg_info->msg_mime == NULL)
return MAIL_ERROR_INVAL;
str = mmap_string_new("");
if (str == NULL) {
res = MAIL_ERROR_MEMORY;
goto err;
}
col = 0;
if (mime->mm_content_type != NULL) {
r = mailmime_content_write_mem(str, &col, mime->mm_content_type);
if (r != MAILIMF_NO_ERROR) {
res = maildriver_imf_error_to_mail_error(r);
goto free;
}
}
if (mime->mm_mime_fields != NULL) {
r = mailmime_fields_write_mem(str, &col, mime->mm_mime_fields);
if (r != MAILIMF_NO_ERROR) {
res = maildriver_imf_error_to_mail_error(r);
goto free;
}
}
mailimf_string_write_mem(str, &col, "\r\n", 2);
r = mmap_string_ref(str);
if (r < 0) {
res = MAIL_ERROR_MEMORY;
goto free;
}
* result = str->str;
* result_len = str->len;
return MAIL_NO_ERROR;
free:
mmap_string_free(str);
err:
return res;
}
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;
}
static int
mailpop3_get_content(mailpop3 * f, struct mailpop3_msg_info * msginfo,
char ** result, size_t * result_len)
{
char * response;
char * result_multiline;
MMAPString * buffer;
int r;
response = read_line(f);
if (response == NULL)
return MAILPOP3_ERROR_STREAM;
r = parse_response(f, response);
if (r != RESPONSE_OK)
return MAILPOP3_ERROR_NO_SUCH_MESSAGE;
buffer = mmap_string_new("");
if (buffer == NULL)
return MAILPOP3_ERROR_MEMORY;
result_multiline = read_multiline(f, msginfo->msg_size, buffer);
if (result_multiline == NULL) {
mmap_string_free(buffer);
return MAILPOP3_ERROR_STREAM;
}
else {
r = mmap_string_ref(buffer);
if (r < 0) {
mmap_string_free(buffer);
return MAILPOP3_ERROR_MEMORY;
}
* result = result_multiline;
* result_len = buffer->len;
return MAILPOP3_NO_ERROR;
}
}
static int newsnntp_get_content(newsnntp * f, char ** result,
size_t * result_len)
{
int r;
char * response;
MMAPString * buffer;
char * result_multiline;
response = read_line(f);
if (response == NULL)
return NEWSNNTP_ERROR_STREAM;
r = parse_response(f, response);
switch (r) {
case 480:
return NEWSNNTP_ERROR_REQUEST_AUTHORIZATION_USERNAME;
case 381:
return NEWSNNTP_WARNING_REQUEST_AUTHORIZATION_PASSWORD;
case 220:
case 221:
case 222:
case 223:
buffer = mmap_string_new("");
if (buffer == NULL)
return NEWSNNTP_ERROR_MEMORY;
result_multiline = read_multiline(f, 0, buffer);
if (result_multiline == NULL) {
mmap_string_free(buffer);
return NEWSNNTP_ERROR_MEMORY;
}
else {
r = mmap_string_ref(buffer);
if (r < 0) {
mmap_string_free(buffer);
return NEWSNNTP_ERROR_MEMORY;
}
* result = result_multiline;
* result_len = buffer->len;
return NEWSNNTP_NO_ERROR;
}
case 412:
return NEWSNNTP_ERROR_NO_NEWSGROUP_SELECTED;
case 420:
return NEWSNNTP_ERROR_NO_ARTICLE_SELECTED;
case 423:
return NEWSNNTP_ERROR_INVALID_ARTICLE_NUMBER;
case 430:
return NEWSNNTP_ERROR_ARTICLE_NOT_FOUND;
default:
return NEWSNNTP_ERROR_UNEXPECTED_RESPONSE;
}
}
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;
}
LIBETPAN_EXPORT
int charconv_buffer(const char * tocode, const char * fromcode,
const char * str, size_t length,
char ** result, size_t * result_len)
{
#ifdef HAVE_ICONV
iconv_t conv;
size_t iconv_r;
int r;
char * out;
char * pout;
size_t out_size;
size_t old_out_size;
size_t count;
#endif
int res;
MMAPString * mmapstr;
if (extended_charconv != NULL) {
size_t result_length;
result_length = length * 6;
mmapstr = mmap_string_sized_new( result_length + 1);
*result_len = 0;
if (mmapstr == NULL) {
res = MAIL_CHARCONV_ERROR_MEMORY;
} else {
res = (*extended_charconv)( tocode, fromcode, str, length, mmapstr->str, &result_length);
if (res != MAIL_CHARCONV_ERROR_UNKNOWN_CHARSET) {
if (res == MAIL_CHARCONV_NO_ERROR) {
*result = mmapstr->str;
res = mmap_string_ref(mmapstr);
if (res < 0) {
res = MAIL_CHARCONV_ERROR_MEMORY;
mmap_string_free(mmapstr);
} else {
mmap_string_set_size( mmapstr, result_length); /* can't fail */
*result_len = result_length;
}
}
free( *result);
}
return res;
}
/* else, let's try with iconv, if available */
}
#ifndef HAVE_ICONV
return MAIL_CHARCONV_ERROR_UNKNOWN_CHARSET;
#else
conv = iconv_open(tocode, fromcode);
if (conv == (iconv_t) -1) {
res = MAIL_CHARCONV_ERROR_UNKNOWN_CHARSET;
goto err;
}
out_size = 6 * length; /* UTF-8 can be encoded up to 6 bytes */
mmapstr = mmap_string_sized_new(out_size + 1);
if (mmapstr == NULL) {
res = MAIL_CHARCONV_ERROR_MEMORY;
goto err;
}
out = mmapstr->str;
pout = out;
old_out_size = out_size;
iconv_r = mail_iconv(conv, &str, &length, &pout, &out_size, NULL, "?");
if (iconv_r == (size_t) -1) {
res = MAIL_CHARCONV_ERROR_CONV;
goto free;
}
iconv_close(conv);
* pout = '\0';
count = old_out_size - out_size;
r = mmap_string_ref(mmapstr);
if (r < 0) {
res = MAIL_CHARCONV_ERROR_MEMORY;
goto free;
}
* result = out;
* result_len = count;
return MAIL_CHARCONV_NO_ERROR;
free:
mmap_string_free(mmapstr);
err:
return res;
#endif
}
