static int
pop_create_header (struct _pop3_message *mpm)
{
int status;
mu_header_t header = NULL;
status = mu_header_create (&header, NULL, 0);
if (status)
return status;
mu_header_set_fill (header, pop_header_fill, mpm);
mu_message_set_header (mpm->message, header, mpm);
return 0;
}
int
mu_message_encapsulate (mu_message_t msg, mu_message_t *newmsg,
mu_mime_io_buffer_t info)
{
mu_stream_t istream, ostream;
int ret = 0;
mu_message_t tmsg = NULL;
if (newmsg == NULL)
return MU_ERR_OUT_PTR_NULL;
if (msg == NULL)
{
mu_header_t hdr;
ret = mu_message_create (&tmsg, NULL);
if (ret)
return ret;
msg = tmsg;
#define MSG822_HEADER "Content-Type: message/rfc822\n" \
"Content-Transfer-Encoding: 7bit\n\n"
if ((ret = mu_header_create (&hdr,
MSG822_HEADER,
sizeof (MSG822_HEADER) - 1)) == 0)
ret = mu_message_set_header (msg, hdr, NULL);
#undef MSG822_HEADER
if (ret)
{
mu_message_destroy (&msg, NULL);
return ret;
}
}
if ((ret = _attachment_setup (&info, msg, &ostream)) != 0)
{
mu_message_destroy (&tmsg, NULL);
return ret;
}
info->msg = msg;
if (ret == 0 && (ret = mu_message_get_streamref (msg, &istream)) == 0)
{
mu_stream_seek (istream, 0, MU_SEEK_SET, NULL);
ret = mu_stream_copy (ostream, istream, 0, NULL);
mu_stream_destroy (&istream);
}
if (ret == 0)
*newmsg = info->msg;
mu_stream_destroy (&ostream);
_attachment_free (info, ret && ret != EAGAIN);
return ret;
}
/* Build a mime response message from original message MSG. TEXT
is the message text.
*/
static int
build_mime (mu_sieve_machine_t mach, mu_list_t tags, mu_mime_t *pmime,
mu_message_t msg, const char *text)
{
mu_mime_t mime = NULL;
mu_message_t newmsg;
mu_stream_t stream, input;
mu_header_t hdr;
mu_body_t body;
const char *header =
"Content-Type: text/plain;charset=" MU_SIEVE_CHARSET "\n"
"Content-Transfer-Encoding: 8bit\n\n";
int rc;
mu_mime_create (&mime, NULL, 0);
mu_message_create (&newmsg, NULL);
mu_message_get_body (newmsg, &body);
if ((rc = mu_static_memory_stream_create (&input, text, strlen (text))))
{
mu_sieve_error (mach,
_("cannot create temporary stream: %s"),
mu_strerror (rc));
mu_mime_destroy (&mime);
mu_message_destroy (&newmsg, NULL);
return 1;
}
if (mu_sieve_tag_lookup (tags, "mime", NULL))
{
mu_stream_t fstr;
rc = mu_filter_create (&fstr, input, "base64",
MU_FILTER_ENCODE,
MU_STREAM_READ);
mu_stream_unref (input);
if (rc == 0)
{
header = "Content-Type: text/plain;charset=" MU_SIEVE_CHARSET "\n"
"Content-Transfer-Encoding: base64\n\n";
input = fstr;
}
}
rc = mu_body_get_streamref (body, &stream);
if (rc)
{
mu_sieve_error (mach,
_("cannot get input body stream: %s"),
mu_strerror (rc));
mu_mime_destroy (&mime);
mu_message_destroy (&newmsg, NULL);
mu_stream_destroy (&input);
return 1;
}
rc = mu_stream_copy (stream, input, 0, NULL);
if (rc)
{
mu_sieve_error (mach,
_("stream copy failed: %s"),
mu_strerror (rc));
mu_mime_destroy (&mime);
mu_message_destroy (&newmsg, NULL);
mu_stream_destroy (&input);
mu_stream_destroy (&stream);
return 1;
}
mu_stream_destroy (&input);
mu_header_create (&hdr, header, strlen (header));
mu_message_set_header (newmsg, hdr, NULL);
mu_mime_add_part (mime, newmsg);
mu_message_unref (newmsg);
*pmime = mime;
return 0;
}
int
mu_message_create_attachment (const char *content_type, const char *encoding,
const char *filename, mu_message_t *newmsg)
{
mu_header_t hdr;
mu_body_t body;
mu_stream_t fstream = NULL, tstream = NULL;
char *header = NULL, *name = NULL, *fname = NULL;
int ret;
if (newmsg == NULL)
return MU_ERR_OUT_PTR_NULL;
if (filename == NULL)
return EINVAL;
if ((ret = mu_message_create (newmsg, NULL)) == 0)
{
if (content_type == NULL)
content_type = "text/plain";
if (encoding == NULL)
encoding = "7bit";
if ((fname = strdup (filename)) != NULL)
{
name = strrchr (fname, '/');
if (name)
name++;
else
name = fname;
ret = mu_asprintf (&header,
"Content-Type: %s; name=%s\n"
"Content-Transfer-Encoding: %s\n"
"Content-Disposition: attachment; filename=%s\n\n",
content_type, name, encoding, name);
if (ret == 0)
{
if ((ret = mu_header_create (&hdr, header,
strlen (header))) == 0)
{
mu_stream_t bstr;
mu_message_get_body (*newmsg, &body);
mu_body_get_streamref (body, &bstr);
if ((ret = mu_file_stream_create (&fstream, filename,
MU_STREAM_READ)) == 0)
{
if ((ret = mu_filter_create (&tstream, fstream, encoding,
MU_FILTER_ENCODE,
MU_STREAM_READ)) == 0)
{
mu_stream_copy (bstr, tstream, 0, NULL);
mu_stream_unref (tstream);
mu_message_set_header (*newmsg, hdr, NULL);
}
}
mu_stream_unref (bstr);
free (header);
}
}
}
}
if (ret)
{
if (*newmsg)
mu_message_destroy (newmsg, NULL);
if (hdr)
mu_header_destroy (&hdr);
if (fstream)
mu_stream_destroy (&fstream);
if (fname)
free (fname);
}
return ret;
}
static int
nntp_mailbox_get_message (mu_mailbox_t mbox, size_t msgno, mu_message_t *pmsg)
{
m_nntp_t m_nntp = mbox->data;
msg_nntp_t msg_nntp;
mu_message_t msg = NULL;
int status;
size_t i;
/* Sanity. */
if (pmsg == NULL)
return MU_ERR_OUT_PTR_NULL;
msgno--;
mu_monitor_rdlock (mbox->monitor);
/* See if we have already this message. */
for (i = 0; i < m_nntp->messages_count; i++)
{
if (m_nntp->messages[i])
{
if (m_nntp->messages[i]->msgno == msgno + m_nntp->low)
{
*pmsg = m_nntp->messages[i]->message;
mu_monitor_unlock (mbox->monitor);
return 0;
}
}
}
mu_monitor_unlock (mbox->monitor);
msg_nntp = calloc (1, sizeof (*msg_nntp));
if (msg_nntp == NULL)
return ENOMEM;
/* Back pointer. */
msg_nntp->m_nntp = m_nntp;
msg_nntp->msgno = msgno + m_nntp->low;
/* Create the message. */
{
mu_stream_t stream = NULL;
if ((status = mu_message_create (&msg, msg_nntp)) != 0
|| (status = mu_stream_create (&stream, mbox->flags, msg)) != 0)
{
mu_stream_destroy (&stream, msg);
mu_message_destroy (&msg, msg_nntp);
free (msg_nntp);
return status;
}
/* Help for the readline()s */
mu_stream_set_read (stream, nntp_message_read, msg);
mu_stream_set_get_transport2 (stream, nntp_message_get_transport2, msg);
mu_message_set_stream (msg, stream, msg_nntp);
mu_message_set_size (msg, nntp_message_size, msg_nntp);
}
/* Create the header. */
{
mu_header_t header = NULL;
if ((status = mu_header_create (&header, NULL, 0, msg)) != 0)
{
mu_message_destroy (&msg, msg_nntp);
free (msg_nntp);
return status;
}
mu_header_set_fill (header, nntp_header_fill, msg);
mu_message_set_header (msg, header, msg_nntp);
}
/* Create the body and its stream. */
{
mu_body_t body = NULL;
mu_stream_t stream = NULL;
if ((status = mu_body_create (&body, msg)) != 0
|| (status = mu_stream_create (&stream, mbox->flags, body)) != 0)
{
mu_body_destroy (&body, msg);
mu_stream_destroy (&stream, body);
mu_message_destroy (&msg, msg_nntp);
free (msg_nntp);
return status;
}
/* Helps for the readline()s */
mu_stream_set_read (stream, nntp_body_read, body);
mu_stream_set_get_transport2 (stream, nntp_body_get_transport2, body);
mu_body_set_size (body, nntp_body_size, msg);
mu_body_set_lines (body, nntp_body_lines, msg);
mu_body_set_stream (body, stream, msg);
mu_message_set_body (msg, body, msg_nntp);
}
/* Set the UID on the message. */
mu_message_set_uid (msg, nntp_message_uid, msg_nntp);
/* Add it to the list. */
mu_monitor_wrlock (mbox->monitor);
{
msg_nntp_t *m ;
m = realloc (m_nntp->messages, (m_nntp->messages_count + 1)*sizeof (*m));
if (m == NULL)
{
mu_message_destroy (&msg, msg_nntp);
free (msg_nntp);
mu_monitor_unlock (mbox->monitor);
return ENOMEM;
}
m_nntp->messages = m;
m_nntp->messages[m_nntp->messages_count] = msg_nntp;
m_nntp->messages_count++;
}
mu_monitor_unlock (mbox->monitor);
/* Save The message pointer. */
mu_message_set_mailbox (msg, mbox, msg_nntp);
*pmsg = msg_nntp->message = msg;
return 0;
}
static int
new_message (mu_mailbox_t mailbox, mbox_message_t mum, mu_message_t *pmsg)
{
int status;
mu_message_t msg;
/* Get an empty message struct. */
status = mu_message_create (&msg, mum);
if (status != 0)
return status;
/* Set the header. */
{
mu_header_t header = NULL;
status = mu_header_create (&header, NULL, 0, msg);
if (status != 0)
{
mu_message_destroy (&msg, mum);
return status;
}
mu_header_set_fill (header, mbox_header_fill, msg);
mu_message_set_header (msg, header, mum);
}
/* Set the attribute. */
{
mu_attribute_t attribute;
status = mu_attribute_create (&attribute, msg);
if (status != 0)
{
mu_message_destroy (&msg, mum);
return status;
}
mu_attribute_set_get_flags (attribute, mbox_get_attr_flags, msg);
mu_attribute_set_set_flags (attribute, mbox_set_attr_flags, msg);
mu_attribute_set_unset_flags (attribute, mbox_unset_attr_flags, msg);
mu_message_set_attribute (msg, attribute, mum);
}
/* Prepare the body. */
{
mu_body_t body = NULL;
mu_stream_t stream = NULL;
if ((status = mu_body_create (&body, msg)) != 0
|| (status = mu_stream_create (&stream,
mailbox->flags | MU_STREAM_SEEKABLE,
body)) != 0)
{
mu_body_destroy (&body, msg);
mu_stream_destroy (&stream, body);
mu_message_destroy (&msg, mum);
return status;
}
mu_stream_set_read (stream, mbox_body_read, body);
mu_stream_set_readline (stream, mbox_body_readline, body);
mu_stream_set_get_transport2 (stream, mbox_get_body_transport, body);
mu_stream_set_size (stream, mbox_stream_size, body);
mu_body_set_stream (body, stream, msg);
mu_body_set_size (body, mbox_body_size, msg);
mu_body_set_lines (body, mbox_body_lines, msg);
mu_message_set_body (msg, body, mum);
}
/* Set the envelope. */
{
mu_envelope_t envelope= NULL;
status = mu_envelope_create (&envelope, msg);
if (status != 0)
{
mu_message_destroy (&msg, mum);
return status;
}
mu_envelope_set_sender (envelope, mbox_envelope_sender, msg);
mu_envelope_set_date (envelope, mbox_envelope_date, msg);
mu_message_set_envelope (msg, envelope, mum);
}
/* Set the UID. */
mu_message_set_uid (msg, mbox_message_uid, mum);
mu_message_set_qid (msg, mbox_message_qid, mum);
/* Attach the message to the mailbox mbox data. */
mum->message = msg;
mu_message_set_mailbox (msg, mailbox, mum);
*pmsg = msg;
return 0;
}
