static size_t
imap4d_tokbuf_getline (struct imap4d_tokbuf *tok)
{
char buffer[512];
size_t level = tok->level;
do
{
size_t len;
int rc;
rc = mu_stream_readline (iostream, buffer, sizeof (buffer), &len);
check_input_err (rc, len);
imap4d_tokbuf_expand (tok, len);
memcpy (tok->buffer + tok->level, buffer, len);
tok->level += len;
}
while (tok->level && tok->buffer[tok->level - 1] != '\n');
tok->buffer[--tok->level] = 0;
if (tok->buffer[tok->level - 1] == '\r')
tok->buffer[--tok->level] = 0;
while (tok->level > 0 && mu_isblank (tok->buffer[tok->level-1]))
tok->buffer[--tok->level] = 0;
return level;
}
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
mbox_readstream (mbox_message_t mum, char *buffer, size_t buflen,
mu_off_t off, size_t *pnread, int isreadline,
mu_off_t start, mu_off_t end)
{
size_t nread = 0;
int status = 0;
if (buffer == NULL || buflen == 0)
{
if (pnread)
*pnread = nread;
return 0;
}
mu_monitor_rdlock (mum->mud->mailbox->monitor);
#ifdef WITH_PTHREAD
/* read() is cancellation point since we're doing a potentially
long operation. Lets make sure we clean the state. */
pthread_cleanup_push (mbox_cleanup, (void *)mum->mud->mailbox);
#endif
{
mu_off_t ln = end - (start + off);
if (ln > 0)
{
/* Position the file pointer and the buffer. */
nread = ((size_t)ln < buflen) ? (size_t)ln : buflen;
if (isreadline)
status = mu_stream_readline (mum->mud->mailbox->stream,
buffer, buflen,
start + off, &nread);
else
status = mu_stream_read (mum->mud->mailbox->stream, buffer, nread,
start + off, &nread);
}
}
mu_monitor_unlock (mum->mud->mailbox->monitor);
#ifdef WITH_PTHREAD
pthread_cleanup_pop (0);
#endif
if (pnread)
*pnread = nread;
return status;
}
void
cmd_readline (int argc, char **argv)
{
char *buf;
size_t size;
mu_stream_t stream;
size_t nbytes;
if (check_args (argv[0], argc, 1, 2))
return;
size = atoi (argv[1]);
buf = malloc (size);
if (!buf)
abort ();
mu_header_get_stream (header, &stream);
mu_stream_readline (stream, buf, size, 0, &nbytes);
printf ("\"%*.*s\"", (int) nbytes, (int) nbytes, buf);
free (buf);
}
static PyObject *
api_stream_readline (PyObject *self, PyObject *args)
{
int status;
size_t read_count;
char rbuf[1024];
PyObject *py_ret;
PyStream *py_stm;
memset (rbuf, 0, sizeof (rbuf));
if (!PyArg_ParseTuple (args, "O!", &PyStreamType, &py_stm))
return NULL;
status = mu_stream_readline (py_stm->stm, rbuf, sizeof (rbuf), &read_count);
py_ret = PyTuple_New (3);
PyTuple_SetItem (py_ret, 0, PyInt_FromLong (status));
PyTuple_SetItem (py_ret, 1, PyString_FromString (rbuf));
PyTuple_SetItem (py_ret, 2, PyInt_FromLong (read_count));
return _ro (py_ret);
}
void
message_display_parts (mu_message_t msg, int indent)
{
int ret, j;
size_t nparts;
mu_message_t part;
mu_header_t hdr;
mu_stream_t str;
mu_body_t body;
int ismulti;
size_t nbytes;
/* How many parts does the message has? */
if ((ret = mu_message_get_num_parts (msg, &nparts)) != 0)
{
fprintf (stderr, "mu_message_get_num_parts - %s\n", mu_strerror (ret));
exit (2);
}
/* Iterate through all the parts.
Treat type "message/rfc822" differently, since it is a message of
its own that can have other subparts(recursive). */
for (j = 1; j <= nparts; j++)
{
int status;
const char *hvalue;
char *type = NULL;
const char *encoding = "";
MU_ASSERT (mu_message_get_part (msg, j, &part));
MU_ASSERT (mu_message_get_header (part, &hdr));
status = mu_header_sget_value (hdr, MU_HEADER_CONTENT_TYPE,
&hvalue);
if (status == MU_ERR_NOENT)
/* nothing */;
else if (status != 0)
mu_error ("Cannot get header value: %s", mu_strerror (status));
else
{
status = mu_mimehdr_aget_disp (hvalue, &type);
if (status)
mu_error ("Cannot extract content type field: %s",
mu_strerror (status));
}
printf ("%*.*sType of part %d = %s\n", indent, indent, "",
j, type ? type : "");
print_message_part_sizes (part, indent);
if (mu_header_sget_value (hdr, MU_HEADER_CONTENT_TRANSFER_ENCODING,
&encoding))
encoding = "";
ismulti = 0;
if ((type
&& mu_c_strcasecmp (type, "message/rfc822") == 0)
|| (mu_message_is_multipart (part, &ismulti) == 0 && ismulti))
{
if (!ismulti)
MU_ASSERT (mu_message_unencapsulate (part, &part, NULL));
MU_ASSERT (mu_message_get_header (part, &hdr));
if (mu_header_sget_value (hdr, MU_HEADER_FROM, &from))
from = "";
if (mu_header_sget_value (hdr, MU_HEADER_SUBJECT, &subject))
subject = "";
printf ("%*.*sEncapsulated message : %s\t%s\n",
indent, indent, "", from, subject);
printf ("%*.*sBegin\n", indent, indent, "");
message_display_parts (part, indent + indent_level);
mu_message_destroy (&part, NULL);
}
else if (!type
|| (mu_c_strcasecmp (type, "text/plain") == 0)
|| (mu_c_strcasecmp (type, "text/html")) == 0)
{
printf ("%*.*sText Message\n", indent, indent, "");
printf ("%*.*sBegin\n", indent, indent, "");
mu_message_get_body (part, &body);
mu_body_get_streamref (body, &str);
/* Make sure the original body stream is not closed when
str gets destroyed */
mu_filter_create (&str, str, encoding, MU_FILTER_DECODE,
MU_STREAM_READ);
while (mu_stream_readline (str, buf, sizeof (buf), &nbytes) == 0
&& nbytes)
{
printf ("%*.*s%s", indent, indent, "", buf);
}
mu_stream_destroy (&str);
}
else
{
/* Save the attachements. */
char *fname = NULL;
mu_message_aget_decoded_attachment_name (part, charset,
&fname, NULL);
if (fname == NULL)
fname = mu_tempname (NULL);
printf ("%*.*sAttachment - saving [%s]\n", indent, indent, "",
fname);
printf ("%*.*sBegin\n", indent, indent, "");
if (charset)
{
mu_mime_io_buffer_t info;
mu_mime_io_buffer_create (&info);
mu_mime_io_buffer_set_charset (info, charset);
MU_ASSERT (mu_message_save_attachment (part, NULL, info));
mu_mime_io_buffer_destroy (&info);
}
else
MU_ASSERT (mu_message_save_attachment (part, fname, NULL));
if (print_attachments)
print_file (fname, indent);
free (fname);
}
printf ("\n%*.*sEnd\n", indent, indent, "");
free (type);
}
}
/* Read a complete line from the nntp server. Transform CRLF to LF, remove
the stuff byte termination octet ".", put a null in the buffer
when done. And Do a select() (stream_is_readready()) for the timeout. */
static int
mu_nntp_getline (mu_nntp_t nntp)
{
size_t n = 0;
size_t total = nntp->io.ptr - nntp->io.buf;
int status = 0;
/* Must get a full line before bailing out. */
do
{
/* Timeout with select(), note that we have to reset select()
since on linux tv is modified when error. */
if (nntp->timeout)
{
int ready = mu_nntp_carrier_is_ready (nntp->carrier,
MU_STREAM_READY_RD,
nntp->timeout);
if (ready == 0)
return ETIMEDOUT;
}
status = mu_stream_readline (nntp->carrier,
nntp->io.buf + total,
nntp->io.len - total, &n);
if (status != 0)
return status;
/* The server went away: It maybe a timeout and some nntp server
does not send the -ERR. Consider this like an error. */
if (n == 0)
return EIO;
total += n;
nntp->io.nl = memchr (nntp->io.buf, '\n', total);
if (nntp->io.nl == NULL) /* Do we have a full line. */
{
/* Allocate a bigger buffer ? */
if (total >= nntp->io.len - 1)
{
nntp->io.len *= 2;
nntp->io.buf = realloc (nntp->io.buf, nntp->io.len + 1);
if (nntp->io.buf == NULL)
return ENOMEM;
}
}
nntp->io.ptr = nntp->io.buf + total;
}
while (nntp->io.nl == NULL); /* Bail only if we have a complete line. */
/* When examining a multi-line response, the client checks to see if the
line begins with the termination octet "."(DOT). If yes and if octets
other than CRLF follow, the first octet of the line (the termination
octet) is stripped away. */
if (total >= 3 && nntp->io.buf[0] == '.')
{
if (nntp->io.buf[1] != '\r' && nntp->io.buf[2] != '\n')
{
memmove (nntp->io.buf, nntp->io.buf + 1, total - 1);
nntp->io.ptr--;
nntp->io.nl--;
}
/* And if CRLF immediately follows the termination character, then
the response from the NNTP server is ended and the line containing
".CRLF" is not considered part of the multi-line response. */
else if (nntp->io.buf[1] == '\r' && nntp->io.buf[2] == '\n')
{
nntp->io.buf[0] = '\0';
nntp->io.ptr = nntp->io.buf;
nntp->io.nl = NULL;
}
}
/* \r\n --> \n\0, conversion. */
if (nntp->io.nl > nntp->io.buf)
{
*(nntp->io.nl - 1) = '\n';
*(nntp->io.nl) = '\0';
nntp->io.ptr = nntp->io.nl;
}
return status;
}
/* FIXME: Do we need to escape body line that begins with "From "? This
will require reading the body line by line instead of by chunks,
considerably hurting perfomance when expunging. But should not this
be the responsibility of the client ? */
static int
mbox_append_message0 (mu_mailbox_t mailbox, mu_message_t msg, mu_off_t *psize,
int is_expunging, int first)
{
mbox_data_t mud = mailbox->data;
int status = 0;
size_t n = 0;
char nl = '\n';
size_t orig_size = *psize;
char *s;
switch (mud->state)
{
case MBOX_NO_STATE:
mud->off = 0;
mud->state = MBOX_STATE_APPEND_SENDER;
case MBOX_STATE_APPEND_SENDER:
/* Generate the sender for the "From " separator. */
{
char *s;
mu_envelope_t envelope = NULL;
mu_message_get_envelope (msg, &envelope);
status = mu_envelope_aget_sender (envelope, &mud->sender);
switch (status) {
case 0:
break;
case EAGAIN:
return status;
case MU_ERR_NOENT: /* Envelope headers not found: try to guess */
free (mud->sender);
mud->sender = NULL;
status = restore_sender (msg, mud);
if (status == 0)
break;
default:
free (mud->sender);
free (mud->date);
mud->date = mud->sender = NULL;
mud->state = MBOX_NO_STATE;
return status;
}
/* Nuke trailing newline. */
s = strchr (mud->sender, nl);
if (s)
*s = '\0';
mud->state = MBOX_STATE_APPEND_DATE;
}
case MBOX_STATE_APPEND_DATE:
/* Generate a date for the "From " separator. */
{
mu_envelope_t envelope = NULL;
const char *envarr[5];
mu_message_get_envelope (msg, &envelope);
status = mu_envelope_aget_date (envelope, &mud->date);
switch (status) {
case 0:
break;
case EAGAIN:
return status;
case MU_ERR_NOENT: /* Envelope headers not found: try to guess */
free (mud->date);
mud->date = NULL;
status = restore_date (msg, mud);
if (status == 0)
break;
default:
free (mud->sender);
free (mud->date);
mud->date = mud->sender = NULL;
mud->state = MBOX_NO_STATE;
return status;
}
/* Nuke trailing newline. */
s = strchr (mud->date, nl);
if (s)
*s = '\0';
/* Write the separator to the mailbox. */
envarr[0] = "From ";
envarr[1] = mud->sender;
envarr[2] = " ";
envarr[3] = mud->date;
envarr[4] = "\n";
status = write_array (mailbox->stream, psize, 5, envarr);
if (status)
break;
free (mud->sender);
free (mud->date);
mud->sender = mud->date = NULL;
/* If we are not expunging get the message in one block via the stream
message instead of the header/body. This is good for POP where
there is no separation between header and body(RETR). */
if (! is_expunging)
{
mud->state = MBOX_STATE_APPEND_MESSAGE;
break;
}
mud->state = MBOX_STATE_APPEND_HEADER;
}
case MBOX_STATE_APPEND_HEADER:
/* Append the Header. */
{
char buffer[1024];
size_t nread = 0;
mu_stream_t is = NULL;
mu_header_t header = NULL;
mu_message_get_header (msg, &header);
mu_header_get_stream (header, &is);
do
{
status = mu_stream_readline (is, buffer, sizeof (buffer), mud->off,
&nread);
if (status != 0)
{
if (status != EAGAIN)
{
mud->state = MBOX_NO_STATE;
mud->off = 0;
}
mu_stream_truncate (mailbox->stream, orig_size);
return status;
}
mud->off += nread;
if (*buffer == '\n')
break;
/* We do not copy the Status since it is rewritten by the
attribute code below. Ditto for X-UID and X-IMAPBase.
FIXME:
- We have a problem here the header may not fit the buffer.
- Should we skip the IMAP "X-Status"? */
if ((mu_c_strncasecmp (buffer, "Status", 6) == 0)
|| (mu_c_strncasecmp (buffer, "X-IMAPbase", 10) == 0)
/* FIXME: isn't the length of "X-UID" 5, not 4? And
this will match X-UID and X-UIDL, is this intended? */
|| (mu_c_strncasecmp (buffer, "X-UID", 4) == 0
&& (buffer[5] == ':' || buffer[5] == ' '
|| buffer[5] == '\t')))
continue;
status = mu_stream_write (mailbox->stream, buffer, nread,
*psize, &n);
if (status)
break;
*psize += n;
}
while (nread > 0);
mud->off = 0;
/* Rewrite the X-IMAPbase marker. */
if (first && is_expunging)
{
n = sprintf (buffer, "X-IMAPbase: %lu %u\n",
(unsigned long) mud->uidvalidity,
(unsigned) mud->uidnext);
status = mu_stream_write (mailbox->stream, buffer, n, *psize, &n);
if (status)
break;
*psize += n;
}
mud->state = MBOX_STATE_APPEND_ATTRIBUTE;
}
case MBOX_STATE_APPEND_ATTRIBUTE:
/* Put the new attributes. */
{
#define STATUS_PREFIX_LEN (sizeof(MU_HEADER_STATUS) - 1 + 2)
char abuf[STATUS_PREFIX_LEN + MU_STATUS_BUF_SIZE + 1];
size_t na = 0;
mu_attribute_t attr = NULL;
strcpy(abuf, MU_HEADER_STATUS);
strcat(abuf, ": ");
mu_message_get_attribute (msg, &attr);
mu_attribute_to_string (attr, abuf + STATUS_PREFIX_LEN,
sizeof(abuf) - STATUS_PREFIX_LEN - 1, &na);
strcat (abuf, "\n");
na = strlen (abuf);
mu_stream_write (mailbox->stream, abuf, na, *psize, &n);
if (status != 0)
break;
*psize += n;
mud->state = MBOX_STATE_APPEND_UID;
}
case MBOX_STATE_APPEND_UID:
/* The new X-UID. */
{
char suid[64];
size_t uid = 0;
if (is_expunging)
{
status = mu_message_get_uid (msg, &uid);
if (status == EAGAIN)
return status;
}
else
uid = mud->uidnext++;
if (status == 0 || uid != 0)
{
n = sprintf (suid, "X-UID: %u\n", (unsigned) uid);
/* Put the UID. */
status = mu_stream_write (mailbox->stream, suid, n, *psize, &n);
if (status)
break;
*psize += n;
}
/* New line separator of the Header. */
status = mu_stream_write (mailbox->stream, &nl , 1, *psize, &n);
if (status)
break;
*psize += n;
mud->state = MBOX_STATE_APPEND_BODY;
}
case MBOX_STATE_APPEND_BODY:
/* Append the Body. */
{
char buffer[1024];
size_t nread = 0;
mu_stream_t is = NULL;
mu_body_t body = NULL;
mu_message_get_body (msg, &body);
mu_body_get_stream (body, &is);
do
{
status = mu_stream_read (is, buffer, sizeof (buffer), mud->off,
&nread);
if (status != 0)
{
if (status != EAGAIN)
{
mud->state = MBOX_NO_STATE;
mud->off = 0;
}
return status;
}
mud->off += nread;
status = mu_stream_write (mailbox->stream, buffer, nread,
*psize, &n);
if (status)
break;
*psize += n;
}
while (nread > 0);
mud->off = 0;
n = 0;
status = mu_stream_write (mailbox->stream, &nl, 1, *psize, &n);
if (status)
break;
*psize += n;
}
default:
break;
}
/* If not expunging we are taking the stream message. */
if (!is_expunging)
{
switch (mud->state)
{
case MBOX_STATE_APPEND_MESSAGE:
{
/* Append the Message. */
char buffer[1024];
size_t nread = 0;
mu_stream_t is = NULL;
mu_message_get_stream (msg, &is);
do
{
status = mu_stream_read (is, buffer, sizeof (buffer), mud->off,
&nread);
if (status != 0)
{
if (status != EAGAIN)
{
mud->state = MBOX_NO_STATE;
mud->off = 0;
}
mu_stream_truncate (mailbox->stream, orig_size);
return status;
}
status = mu_stream_write (mailbox->stream, buffer, nread,
*psize, &n);
if (status)
break;
mud->off += nread;
*psize += n;
}
while (nread > 0);
if (status)
break;
status = mu_stream_write (mailbox->stream, &nl, 1, *psize, &n);
if (status == 0)
*psize += n;
}
default:
break;
}
} /* is_expunging */
mud->state = MBOX_NO_STATE;
if (status)
mu_stream_truncate (mailbox->stream, orig_size);
else
mu_stream_flush (mailbox->stream);
return status;
}
int
mu_progmailer_send (struct _mu_progmailer *pm, mu_message_t msg)
{
int status;
mu_stream_t stream = NULL;
char buffer[512];
size_t len = 0;
int rc;
mu_header_t hdr;
mu_body_t body;
int found_nl = 0;
int exit_status;
if (!pm || !msg)
return EINVAL;
mu_message_get_header (msg, &hdr);
status = mu_header_get_streamref (hdr, &stream);
if (status)
{
mu_debug (MU_DEBCAT_MAILER, MU_DEBUG_ERROR,
("cannot get header stream: %s", mu_strerror (status)));
return status;
}
mu_debug (MU_DEBCAT_MAILER, MU_DEBUG_TRACE, ("Sending headers..."));
mu_stream_seek (stream, 0, MU_SEEK_SET, NULL);
while ((status = mu_stream_readline (stream, buffer, sizeof (buffer),
&len)) == 0
&& len != 0)
{
if (mu_c_strncasecmp (buffer, MU_HEADER_FCC, sizeof (MU_HEADER_FCC) - 1))
{
mu_debug (MU_DEBCAT_MAILER, MU_DEBUG_PROT, ("Header: %s", buffer));
if (write (pm->fd, buffer, len) == -1)
{
status = errno;
mu_debug (MU_DEBCAT_MAILER, MU_DEBUG_ERROR,
("write failed: %s", strerror (status)));
break;
}
}
found_nl = (len == 1 && buffer[0] == '\n');
}
if (!found_nl)
{
if (write (pm->fd, "\n", 1) == -1)
{
status = errno;
mu_debug (MU_DEBCAT_MAILER, MU_DEBUG_ERROR,
("write failed: %s", strerror (status)));
}
}
mu_stream_destroy (&stream);
mu_debug (MU_DEBCAT_MAILER, MU_DEBUG_TRACE, ("Sending body..."));
mu_message_get_body (msg, &body);
status = mu_body_get_streamref (body, &stream);
if (status)
{
mu_debug (MU_DEBCAT_MAILER, MU_DEBUG_ERROR,
("cannot get body stream: %s\n", mu_strerror (status)));
return status;
}
mu_stream_seek (stream, 0, MU_SEEK_SET, NULL);
while ((status = mu_stream_read (stream, buffer, sizeof (buffer),
&len)) == 0
&& len != 0)
{
if (write (pm->fd, buffer, len) == -1)
{
status = errno;
mu_debug (MU_DEBCAT_MAILER, MU_DEBUG_ERROR,
("write failed: %s\n", strerror (status)));
break;
}
}
mu_body_get_streamref (body, &stream);
close (pm->fd);
rc = waitpid (pm->pid, &exit_status, 0);
if (status == 0)
{
if (rc < 0)
{
if (errno == ECHILD)
status = 0;
else
{
status = errno;
mu_debug (MU_DEBCAT_MAILER, MU_DEBUG_ERROR,
("waitpid(%lu) failed: %s\n",
(unsigned long) pm->pid, strerror (status)));
}
}
else if (WIFEXITED (exit_status))
{
exit_status = WEXITSTATUS (exit_status);
mu_debug (MU_DEBCAT_MAILER, MU_DEBUG_TRACE,
("%s exited with: %d\n",
pm->command, exit_status));
status = (exit_status == 0) ? 0 : MU_ERR_PROCESS_EXITED;
}
else if (WIFSIGNALED (exit_status))
status = MU_ERR_PROCESS_SIGNALED;
else
status = MU_ERR_PROCESS_UNKNOWN_FAILURE;
}
pm->pid = -1;
return status;
}
