/* Stub to call the fd from message object. */
static int
nntp_message_get_transport2 (mu_stream_t stream, mu_transport_t *pin, mu_transport_t *pout)
{
mu_message_t msg = mu_stream_get_owner (stream);
msg_nntp_t msg_nntp = mu_message_get_owner (msg);
return nntp_get_transport2 (msg_nntp, pin, pout);
}
/* FIXME: change prototype to avoid fixed size buffer */
static int
pop_uidl (mu_message_t msg, char *buffer, size_t buflen, size_t *pnwriten)
{
struct _pop3_message *mpm = mu_message_get_owner (msg);
struct _pop3_mailbox *mpd = mpm->mpd;
size_t len;
if (!mpm->uidl)
{
if (mu_pop3_capa_test (mpd->pop3, "UIDL", NULL) == 0)
{
int status = mu_pop3_uidl (mpd->pop3, mpm->num, &mpm->uidl);
if (status)
return status;
}
else
return ENOSYS;
}
len = strlen (mpm->uidl);
if (buffer)
{
buflen--; /* Leave space for the null. */
buflen = (len > buflen) ? buflen : len;
memcpy (buffer, mpm->uidl, buflen);
buffer[buflen] = 0;
}
else
buflen = len;
if (pnwriten)
*pnwriten = buflen;
return 0;
}
static int
nntp_message_uidl (mu_message_t msg, char *buffer, size_t buflen,
size_t *pnwriten)
{
msg_nntp_t msg_nntp = mu_message_get_owner (msg);
m_nntp_t m_nntp = msg_nntp->m_nntp;
int status = 0;
/* Select first. */
status = nntp_mailbox_messages_count (m_nntp->mailbox, NULL);
if (status != 0)
return status;
if (msg_nntp->mid)
{
size_t len = strlen (msg_nntp->mid);
if (buffer)
{
buflen--; /* Leave space for the null. */
buflen = (len > buflen) ? buflen : len;
memcpy (buffer, msg_nntp->mid, buflen);
buffer[buflen] = '\0';
}
else
buflen = len;
}
else
buflen = 0;
if (pnwriten)
*pnwriten = buflen;
return status;
}
static int
pop_uid (mu_message_t msg, size_t *puid)
{
struct _pop3_message *mpm = mu_message_get_owner (msg);
if (puid)
*puid = mpm->num;
return 0;
}
static int
mbox_message_uid (mu_message_t msg, size_t *puid)
{
mbox_message_t mum = mu_message_get_owner (msg);
if (puid)
*puid = mum->uid;
return 0;
}
static int
mbox_get_body_transport (mu_stream_t is, mu_transport_t *pin,
mu_transport_t *pout)
{
mu_body_t body = mu_stream_get_owner (is);
mu_message_t msg = mu_body_get_owner (body);
mbox_message_t mum = mu_message_get_owner (msg);
return mbox_get_transport2 (mum, pin, pout);
}
static int
mbox_header_fill (mu_header_t header, char *buffer, size_t len,
mu_off_t off, size_t *pnread)
{
mu_message_t msg = mu_header_get_owner (header);
mbox_message_t mum = mu_message_get_owner (msg);
return mbox_readstream (mum, buffer, len, off, pnread, 0,
mum->header_from_end, mum->body);
}
static int
mbox_body_read (mu_stream_t is, char *buffer, size_t buflen,
mu_off_t off, size_t *pnread)
{
mu_body_t body = mu_stream_get_owner (is);
mu_message_t msg = mu_body_get_owner (body);
mbox_message_t mum = mu_message_get_owner (msg);
return mbox_readstream (mum, buffer, buflen, off, pnread, 0,
mum->body, mum->body_end);
}
static int
pop_body_size (mu_body_t body, size_t *psize)
{
mu_message_t msg = mu_body_get_owner (body);
struct _pop3_message *mpm = mu_message_get_owner (msg);
int status = pop_scan_message (mpm);
if (status)
return status;
*psize = mpm->body_end - mpm->body_start;
return 0;
}
static int
pop_body_lines (mu_body_t body, size_t *plines)
{
mu_message_t msg = mu_body_get_owner (body);
struct _pop3_message *mpm = mu_message_get_owner (msg);
int status = pop_scan_message (mpm);
if (status)
return status;
*plines = mpm->body_lines;
return 0;
}
static int
mbox_body_lines (mu_body_t body, size_t *plines)
{
mu_message_t msg = mu_body_get_owner (body);
mbox_message_t mum = mu_message_get_owner (msg);
if (mum == NULL)
return EINVAL;
if (plines)
*plines = mum->body_lines;
return 0;
}
static int
mbox_body_size (mu_body_t body, size_t *psize)
{
mu_message_t msg = mu_body_get_owner (body);
mbox_message_t mum = mu_message_get_owner (msg);
if (mum == NULL)
return EINVAL;
if (psize)
*psize = mum->body_end - mum->body;
return 0;
}
static int
mbox_unset_attr_flags (mu_attribute_t attr, int flags)
{
mu_message_t msg = mu_attribute_get_owner (attr);
mbox_message_t mum = mu_message_get_owner (msg);
if (mum == NULL)
return EINVAL;
mum->attr_flags &= ~flags;
return 0;
}
int
pop_body_get_stream (mu_body_t body, mu_stream_t *pstr)
{
mu_message_t msg = mu_body_get_owner (body);
struct _pop3_message *mpm = mu_message_get_owner (msg);
struct _pop3_mailbox *mpd = mpm->mpd;
int status = pop_scan_message (mpm);
if (status)
return status;
return mu_streamref_create_abridged (pstr, mpd->cache,
mpm->offset + mpm->body_start,
mpm->offset + mpm->body_end - 1);
}
static int
mbox_envelope_sender (mu_envelope_t envelope, char *buf, size_t len,
size_t *pnwrite)
{
mu_message_t msg = mu_envelope_get_owner (envelope);
mbox_message_t mum = mu_message_get_owner (msg);
size_t n = 0;
int status;
char buffer[512];
char *s;
if (mum == NULL)
return EINVAL;
status = mu_stream_readline (mum->mud->mailbox->stream, buffer,
sizeof(buffer),
mum->header_from, &n);
if (status != 0)
{
if (pnwrite)
*pnwrite = 0;
return status;
}
/* Format: "From [sender] [date]" */
/* strlen ("From ") == 5 */
if (n > 5 && (s = strchr (buffer + 5, ' ')) != NULL)
{
/* Put a NULL to isolate the sender string, make a C string. */
*s = '\0';
if (buf && len > 0)
{
len--; /* leave space for the null */
strncpy (buf, buffer + 5, len)[len] = '\0';
len = strlen (buf);
}
else
len = strlen (buffer + 5);
}
else
len = 0;
if (pnwrite)
*pnwrite = len;
return 0;
}
static int
nntp_message_uid (mu_message_t msg, size_t *puid)
{
msg_nntp_t msg_nntp = mu_message_get_owner (msg);
m_nntp_t m_nntp = msg_nntp->m_nntp;
int status;
if (puid)
return 0;
/* Select first. */
status = nntp_mailbox_messages_count (m_nntp->mailbox, NULL);
if (status != 0)
return status;
if (puid)
*puid = msg_nntp->msgno;
return 0;
}
static int
pop_message_lines (mu_message_t msg, size_t *plines, int quick)
{
int rc;
struct _pop3_message *mpm = mu_message_get_owner (msg);
if (!(mpm->flags & _POP3_MSG_LINES))
{
if (quick && !(mpm->flags & _POP3_MSG_CACHED))
return MU_ERR_INFO_UNAVAILABLE;
if (!pop_is_updated (mpm->mpd->mbox))
pop_scan (mpm->mpd->mbox, 1, NULL);
rc = pop_scan_message (mpm);
if (rc)
return rc;
mpm->message_lines = mpm->header_lines + mpm->body_lines + 1;
mpm->flags |= _POP3_MSG_LINES;
}
*plines = mpm->message_lines;
return 0;
}
static int
pop_message_size (mu_message_t msg, size_t *psize)
{
struct _pop3_message *mpm = mu_message_get_owner (msg);
struct _pop3_mailbox *mpd = mpm->mpd;
if (mpm == NULL)
return EINVAL;
if (!(mpm->flags & _POP3_MSG_SIZE))
{
/* FIXME: The size obtained this way may differ from the actual one
by the number of lines in the message. */
int status = mu_pop3_list (mpd->pop3, mpm->num, &mpm->message_size);
if (status)
return status;
mpm->flags |= _POP3_MSG_SIZE;
}
if (psize)
*psize = mpm->message_size;
return 0;
}
/* Message read overload */
static int
nntp_body_read (mu_stream_t stream, char *buffer, size_t buflen, mu_off_t offset, size_t *plen)
{
mu_body_t body = mu_stream_get_owner (stream);
mu_message_t msg = mu_body_get_owner (body);
msg_nntp_t msg_nntp = mu_message_get_owner (msg);
m_nntp_t m_nntp = msg_nntp->m_nntp;
f_nntp_t f_nntp = m_nntp->f_nntp;
int status;
size_t len = 0;
/* Start over. */
if (plen == NULL)
plen = &len;
/* Select first. */
status = nntp_mailbox_messages_count (m_nntp->mailbox, NULL);
if (status != 0)
return status;
if (msg_nntp->bstream == NULL)
{
status = mu_nntp_body (f_nntp->nntp, msg_nntp->msgno, NULL, &msg_nntp->mid, &msg_nntp->bstream);
if (status != 0)
return status;
}
status = mu_stream_read (msg_nntp->bstream, buffer, buflen, offset, plen);
if (status == 0)
{
/* Destroy the stream. */
if (*plen == 0)
{
mu_stream_destroy (&msg_nntp->bstream, NULL);
}
}
return status;
}
int
main (int argc, char **argv)
{
int index;
int rc;
mu_stream_t in, tmp;
mu_message_t msg;
mu_header_t hdr;
mu_iterator_t itr;
const char *file;
char *newval;
mu_off_t size;
mu_body_t body;
mu_stream_t bstr;
MU_APP_INIT_NLS ();
mh_argp_init ();
mh_argp_parse (&argc, &argv, 0, options, mh_option, args_doc, doc,
opt_handler, NULL, &index);
if (index == argc)
{
mu_error (_("file name not given"));
exit (1);
}
file = argv[index];
prompter_init ();
if (erase_seq)
prompter_set_erase (erase_seq);
if (kill_seq)
prompter_set_erase (kill_seq);
if ((rc = mu_stdio_stream_create (&strout, MU_STDOUT_FD, MU_STREAM_WRITE)))
{
mu_error (_("cannot open stdout: %s"), mu_strerror (rc));
return 1;
}
if ((rc = mu_file_stream_create (&in, file, MU_STREAM_RDWR)))
{
mu_error (_("cannot open input file `%s': %s"),
file, mu_strerror (rc));
return 1;
}
rc = mu_stream_to_message (in, &msg);
mu_stream_unref (in);
if (rc)
{
mu_error (_("input stream %s is not a message (%s)"),
file, mu_strerror (rc));
return 1;
}
if ((rc = mu_temp_file_stream_create (&tmp, NULL, 0)))
{
mu_error (_("Cannot open temporary file: %s"),
mu_strerror (rc));
return 1;
}
/* Copy headers */
mu_message_get_header (msg, &hdr);
mu_header_get_iterator (hdr, &itr);
for (mu_iterator_first (itr); !mu_iterator_is_done (itr);
mu_iterator_next (itr))
{
const char *name, *val;
mu_iterator_current_kv (itr, (const void **)&name, (void**)&val);
if (!is_empty_string (val))
{
mu_stream_printf (tmp, "%s: %s\n", name, val);
mu_stream_printf (strout, "%s: %s\n", name, val);
}
else
{
int cont = 0;
mu_opool_t opool;
const char *prompt = name;
mu_opool_create (&opool, 1);
do
{
size_t len;
char *p;
p = prompter_get_value (prompt);
if (!p)
return 1;
prompt = NULL;
if (cont)
{
mu_opool_append_char (opool, '\n');
if (!mu_isspace (p[0]))
mu_opool_append_char (opool, '\t');
}
len = strlen (p);
if (len > 0 && p[len-1] == '\\')
{
len--;
cont = 1;
}
else
cont = 0;
mu_opool_append (opool, p, len);
free (p);
}
while (cont);
mu_opool_append_char (opool, 0);
newval = mu_opool_finish (opool, NULL);
if (!is_empty_string (newval))
mu_stream_printf (tmp, "%s: %s\n", name, newval);
mu_opool_destroy (&opool);
}
}
mu_iterator_destroy (&itr);
mu_stream_printf (strout, "--------\n");
mu_stream_write (tmp, "\n", 1, NULL);
/* Copy body */
if (prepend_option)
{
mu_stream_printf (strout, "\n--------%s\n\n", _("Enter initial text"));
while ((newval = prompter_get_line ()))
{
mu_stream_write (tmp, newval, strlen (newval), NULL);
free (newval);
mu_stream_write (tmp, "\n", 1, NULL);
}
}
mu_message_get_body (msg, &body);
mu_body_get_streamref (body, &bstr);
if (!prepend_option && !rapid_option)
{
mu_stream_copy (strout, bstr, 0, NULL);
mu_stream_seek (bstr, 0, MU_SEEK_SET, NULL);
}
mu_stream_copy (tmp, bstr, 0, NULL);
mu_stream_unref (bstr);
if (!prepend_option && !rapid_option)
{
printf ("\n--------%s\n\n", _("Enter additional text"));
while ((newval = prompter_get_line ()))
{
mu_stream_write (tmp, newval, strlen (newval), NULL);
free (newval);
mu_stream_write (tmp, "\n", 1, NULL);
}
}
/* Destroy the message */
mu_message_destroy (&msg, mu_message_get_owner (msg));
/* Rewind the streams and copy data back to in. */
mu_stream_seek (in, 0, MU_SEEK_SET, NULL);
mu_stream_seek (tmp, 0, MU_SEEK_SET, NULL);
mu_stream_copy (in, tmp, 0, &size);
mu_stream_truncate (in, size);
mu_stream_destroy (&in);
mu_stream_destroy (&tmp);
mu_stream_destroy (&strout);
prompter_done ();
return 0;
}
static int
mbox_message_qid (mu_message_t msg, mu_message_qid_t *pqid)
{
mbox_message_t mum = mu_message_get_owner (msg);
return mu_asprintf (pqid, "%lu", (unsigned long) mum->header_from);
}
static int
pop_message_get_stream (mu_message_t msg, mu_stream_t *pstr)
{
struct _pop3_message *mpm = mu_message_get_owner (msg);
return _pop_message_get_stream (mpm, pstr);
}
