static int
compare_action (void *item, void *data)
{
struct comp_op *op = item;
struct comp_data *dp = data;
char *a, *ap, *b, *bp;
mu_header_t h;
if (mu_message_get_header (dp->m[0], &h)
|| mu_header_aget_value (h, op->field, &a))
return 0;
if (mu_message_get_header (dp->m[1], &h)
|| mu_header_aget_value (h, op->field, &b))
{
free (a);
return 0;
}
ap = a;
bp = b;
if (mu_c_strcasecmp (op->field, MU_HEADER_SUBJECT) == 0)
{
if (mu_c_strncasecmp (ap, "re:", 3) == 0)
ap += 3;
if (mu_c_strncasecmp (b, "re:", 3) == 0)
bp += 3;
}
dp->r = op->comp (ap, bp);
free (a);
free (b);
return dp->r; /* go on until the difference is found */
}
static int
moderator_discard_message (mu_sieve_machine_t mach, mu_message_t request,
const char *from)
{
int rc;
mu_message_t reply;
mu_header_t repl_hdr, req_hdr;
mu_mailer_t mailer;
rc = mu_message_create (&reply, NULL);
if (rc)
return rc;
rc = mu_message_get_header (reply, &repl_hdr);
if (rc)
{
mu_message_destroy (&reply, NULL);
return rc;
}
rc = mu_message_get_header (request, &req_hdr);
if (rc)
{
mu_message_destroy (&reply, NULL);
return rc;
}
if (copy_header (mach, repl_hdr, MU_HEADER_TO, req_hdr, MU_HEADER_FROM)
|| copy_header (mach,
repl_hdr, MU_HEADER_SUBJECT, req_hdr, MU_HEADER_SUBJECT))
{
mu_message_destroy (&reply, NULL);
return rc;
}
if (from)
mu_header_set_value (repl_hdr, MU_HEADER_FROM, from, 0);
mailer = mu_sieve_get_mailer (mach);
rc = mu_mailer_open (mailer, 0);
if (rc)
mu_sieve_error (mach, _("cannot open mailer: %s"),
mu_strerror (rc));
else
{
rc = mu_mailer_send_message (mailer, reply, NULL, NULL);
mu_mailer_close (mailer);
if (rc)
mu_sieve_error (mach, _("cannot send message: %s"),
mu_strerror (rc));
}
mu_message_destroy (&reply, NULL);
return rc;
}
/* %S */
static char *
hdr_q_subject (struct header_call_args *args, void *data)
{
mu_header_t hdr;
char *subj = NULL;
size_t len;
if (args->cols_rest <= 2)
return "\"\"";
mu_message_get_header (args->msg, &hdr);
mu_header_aget_value_unfold (hdr, MU_HEADER_SUBJECT, &subj);
if (!subj)
return "";
util_rfc2047_decode (&subj);
len = strlen (subj);
if (len + 2 > args->cols_rest)
len = args->cols_rest - 2;
header_ensure_space (args, len + 3);
args->buf[0] = '"';
memcpy (args->buf + 1, subj, len);
args->buf[len+1] = '"';
args->buf[len+2] = 0;
free (subj);
return args->buf;
}
/* %d */
static char *
hdr_date (struct header_call_args *args, void *data)
{
char date[80];
mu_header_t hdr;
mu_message_get_header (args->msg, &hdr);
date[0] = 0;
if (mailvar_get (NULL, "datefield", mailvar_type_boolean, 0) == 0
&& mu_header_get_value (hdr, MU_HEADER_DATE,
date, sizeof (date), NULL) == 0)
{
time_t t;
if (mu_parse_date (date, &t, NULL) == 0)
strftime (date, sizeof(date), "%a %b %e %H:%M", localtime (&t));
else
date[0] = 0;
}
if (date[0] == 0)
{
const char *p;
struct tm tm;
mu_timezone tz;
mu_envelope_t env;
mu_message_get_envelope (args->msg, &env);
if (mu_envelope_sget_date (env, &p) == 0
&& mu_parse_ctime_date_time (&p, &tm, &tz) == 0)
strftime (date, sizeof(date), "%a %b %e %H:%M", &tm);
}
return header_buf_string (args, date);
}
int
restore_date (mu_message_t msg, mbox_data_t mud)
{
mu_header_t hdr;
char *date = NULL;
time_t t;
int rc = 0;
if (mu_message_get_header (msg, &hdr) == 0)
mu_header_aget_value (hdr, MU_HEADER_DATE, &date);
if (date && mu_parse_date (date, &t, NULL))
{
char datebuf[MU_ENVELOPE_DATE_LENGTH+1];
/* FIXME: 1. Preserve TZ info */
mu_strftime (datebuf, sizeof datebuf, MU_ENVELOPE_DATE_FORMAT,
localtime (&t));
free (date);
date = strdup (datebuf);
}
else
{
time (&t);
free (date);
date = strdup (ctime (&t));
}
mud->date = date;
if (!mud->date)
rc = ENOMEM;
return rc;
}
int
mu_message_save_attachment (mu_message_t msg, const char *filename,
mu_mime_io_buffer_t info)
{
mu_stream_t istream;
int ret;
mu_header_t hdr;
const char *fname = NULL;
char *partname = NULL;
if (msg == NULL)
return EINVAL;
if ((ret = _attachment_setup (&info, msg, &istream)) != 0)
return ret;
if (ret == 0 && (ret = mu_message_get_header (msg, &hdr)) == 0)
{
if (filename == NULL)
{
ret = mu_message_aget_decoded_attachment_name (msg, info->charset,
&partname, NULL);
if (partname)
fname = partname;
}
else
fname = filename;
if (fname
&& (ret = mu_file_stream_create (&info->fstream, fname,
MU_STREAM_WRITE | MU_STREAM_CREAT)) == 0)
{
const char *content_encoding;
if (mu_header_sget_value (hdr, MU_HEADER_CONTENT_TRANSFER_ENCODING,
&content_encoding))
content_encoding = "7bit";
ret = mu_filter_create (&info->stream, istream, content_encoding,
MU_FILTER_DECODE,
MU_STREAM_READ);
}
}
if (info->stream && istream)
ret = mu_stream_copy (info->fstream, info->stream, 0, NULL);
if (ret != EAGAIN && info)
{
mu_stream_close (info->fstream);
mu_stream_destroy (&info->stream);
mu_stream_destroy (&info->fstream);
}
mu_stream_destroy (&istream);
_attachment_free (info, ret); /* FIXME: or 0? */
/* Free fname if we allocated it. */
if (partname)
free (partname);
return ret;
}
int
mu_message_unencapsulate (mu_message_t msg, mu_message_t *newmsg,
mu_mime_io_buffer_t info)
{
int ret = 0;
mu_header_t hdr;
mu_stream_t istream;
if (msg == NULL)
return EINVAL;
if (newmsg == NULL)
return MU_ERR_OUT_PTR_NULL;
if (info == NULL /* FIXME: not needed? */
&& (ret = mu_message_get_header (msg, &hdr)) == 0)
{
const char *s;
if (!(mu_header_sget_value (hdr, MU_HEADER_CONTENT_TYPE, &s) == 0 &&
mu_c_strncasecmp (s, MESSAGE_RFC822_STR,
sizeof (MESSAGE_RFC822_STR) - 1) == 0))
return EINVAL;
}
if ((ret = _attachment_setup (&info, msg, &istream)) != 0)
return ret;
ret = mu_stream_to_message (istream, &info->msg);
mu_stream_unref (istream);
if (ret == 0)
*newmsg = info->msg;
_attachment_free (info, ret && ret != EAGAIN);
return ret;
}
static int
message_envelope_sender (mu_envelope_t envelope, char *buf, size_t len,
size_t *pnwrite)
{
mu_message_t msg = mu_envelope_get_owner (envelope);
mu_header_t header;
int status;
const char *sender;
struct mu_auth_data *auth = NULL;
static char *hdrnames[] = {
"X-Envelope-Sender",
"X-Envelope-From",
"X-Original-Sender",
"From",
NULL
};
mu_address_t address = NULL;
if (msg == NULL)
return EINVAL;
/* First, try the header */
status = mu_message_get_header (msg, &header);
if (status)
return status;
status = mu_header_sget_firstof (header, hdrnames, &sender, NULL);
if (status)
{
auth = mu_get_auth_by_uid (getuid ());
if (!auth)
return MU_ERR_NOENT;
sender = auth->name;
}
status = mu_address_create (&address, sender);
if (status == 0)
{
status = mu_address_sget_email (address, 1, &sender);
if (status == 0)
{
size_t n = strlen (sender);
if (buf && len > 0)
{
len--; /* One for the null. */
n = (n < len) ? n : len;
memcpy (buf, sender, n);
buf[n] = '\0';
}
if (pnwrite)
*pnwrite = n;
}
mu_address_destroy (&address);
}
if (auth)
mu_auth_data_free (auth);
return status;
}
/* Syntax: addheader [:last] <field-name: string> <value: string>
*/
int
sieve_addheader (mu_sieve_machine_t mach, mu_list_t args, mu_list_t tags)
{
mu_sieve_value_t *val;
const char *field_name;
const char *field_value;
mu_message_t msg;
mu_header_t hdr;
int rc;
val = mu_sieve_value_get (args, 0);
if (!val)
{
mu_sieve_error (mach, "%lu: %s",
(unsigned long) mu_sieve_get_message_num (mach),
_("cannot get field name"));
mu_sieve_abort (mach);
}
field_name = val->v.string;
val = mu_sieve_value_get (args, 1);
if (!val)
{
mu_sieve_error (mach, "%lu: %s",
(unsigned long) mu_sieve_get_message_num (mach),
_("cannot get field value"));
mu_sieve_abort (mach);
}
field_value = val->v.string;
mu_sieve_log_action (mach, "ADDHEADER", "%s: %s", field_name, field_value);
if (mu_sieve_is_dry_run (mach))
return 0;
msg = mu_sieve_get_message (mach);
rc = mu_message_get_header (msg, &hdr);
if (rc)
{
mu_sieve_error (mach, "%lu: %s: %s",
(unsigned long) mu_sieve_get_message_num (mach),
_("cannot get message header"),
mu_strerror (rc));
mu_sieve_abort (mach);
}
rc = (mu_sieve_tag_lookup (tags, "last", NULL) ?
mu_header_append : mu_header_prepend) (hdr, field_name, field_value);
if (rc)
{
mu_sieve_error (mach, "%lu: %s: %s",
(unsigned long) mu_sieve_get_message_num (mach),
_("cannot append message header"),
mu_strerror (rc));
mu_sieve_abort (mach);
}
return 0;
}
int
moderator_message_get_part (mu_sieve_machine_t mach,
mu_message_t msg, size_t index, mu_message_t *pmsg)
{
int rc;
mu_message_t tmp;
mu_header_t hdr = NULL;
char *value;
if ((rc = mu_message_get_part (msg, index, &tmp)))
{
mu_sieve_error (mach, _("cannot get message part #%lu: %s"),
(unsigned long) index, mu_strerror (rc));
return 1;
}
mu_message_get_header (tmp, &hdr);
if (mu_header_aget_value (hdr, MU_HEADER_CONTENT_TYPE, &value) == 0
&& memcmp (value, "message/rfc822", 14) == 0)
{
mu_stream_t str;
mu_body_t body;
free (value);
mu_message_get_body (tmp, &body);
mu_body_get_stream (body, &str);
rc = mu_stream_to_message (str, pmsg);
if (rc)
{
mu_sieve_error (mach,
_("cannot convert MIME part stream to message: %s"),
mu_strerror (rc));
return 1;
}
}
else if (value)
{
mu_sieve_error (mach,
_("expected message type message/rfc822, but found %s"),
value);
free (value);
return 1;
}
else
{
mu_sieve_error (mach, _("no Content-Type header found"));
return 1;
}
return 0;
}
/* %s */
static char *
hdr_subject (struct header_call_args *args, void *data)
{
mu_header_t hdr;
char *subj = NULL;
mu_message_get_header (args->msg, &hdr);
mu_header_aget_value_unfold (hdr, MU_HEADER_SUBJECT, &subj);
util_rfc2047_decode (&subj);
header_buf_string (args, subj);
free (subj);
return args->buf;
}
/* Handler for the numaddr test */
static int
numaddr_test (mu_sieve_machine_t mach, mu_list_t args, mu_list_t tags)
{
mu_sieve_value_t *h, *v;
struct val_ctr vc;
int rc;
if (mu_sieve_get_debug_level (mach) & MU_SIEVE_DEBUG_TRACE)
{
mu_sieve_debug (mach, "NUMADDR");
}
/* Retrieve required arguments: */
/* First argument: list of header names */
h = mu_sieve_value_get (args, 0);
if (!h)
{
mu_sieve_error (mach, "numaddr: can't get argument 1");
mu_sieve_abort (mach);
}
/* Second argument: Limit on the number of addresses */
v = mu_sieve_value_get (args, 1);
if (!v)
{
mu_sieve_error (mach, "numaddr: can't get argument 2");
mu_sieve_abort (mach);
}
/* Fill in the val_ctr structure */
mu_message_get_header (mu_sieve_get_message (mach), &vc.hdr);
vc.count = 0;
vc.limit = v->v.number;
/* Count the addresses */
rc = mu_sieve_vlist_do (h, _count_items, &vc);
/* Here rc >= 1 iff the counted number of addresses is greater or equal
to vc.limit. If `:under' tag was given we reverse the return value */
if (mu_sieve_tag_lookup (tags, "under", NULL))
rc = !rc;
return rc;
}
static void
print_message_part_sizes (mu_message_t part, int indent)
{
mu_body_t body;
mu_header_t hdr;
size_t msize, mlines, hsize, hlines, bsize, blines;
MU_ASSERT (mu_message_size (part, &msize));
MU_ASSERT (mu_message_lines (part, &mlines));
MU_ASSERT (mu_message_get_header (part, &hdr));
MU_ASSERT (mu_header_size (hdr, &hsize));
MU_ASSERT (mu_header_lines (hdr, &hlines));
MU_ASSERT (mu_message_get_body (part, &body));
MU_ASSERT (mu_body_size (body, &bsize));
MU_ASSERT (mu_body_lines (body, &blines));
printf ("%*.*sMessage part size - %lu/%lu: %lu/%lu, %lu/%lu\n",
indent, indent, "",
(unsigned long) msize, (unsigned long) mlines,
(unsigned long) hsize, (unsigned long) hlines,
(unsigned long) bsize, (unsigned long) blines);
}
/* There is no POP3 command to return message attributes, therefore we
have to recurse to reading the "Status:" header. Unfortunately, some
servers remove it when you dowload a message, and in this case a message
will always look like new even if you already read it. There is also
no way to set an attribute on remote mailbox via the POP server and
many server once you do a RETR (and in some cases a TOP) will mark the
message as read (Status: RO). Even worse, some servers may be configured
to delete after the RETR, and some go as much as deleting after the TOP,
since technicaly you can download a message via TOP without RETR'eiving
it. */
static int
pop_get_attribute (mu_attribute_t attr, int *pflags)
{
struct _pop3_message *mpm = mu_attribute_get_owner (attr);
char hdr_status[64];
mu_header_t header = NULL;
if (mpm == NULL || pflags == NULL)
return EINVAL;
if (!(mpm->flags & _POP3_MSG_ATTRSET))
{
hdr_status[0] = '\0';
mu_message_get_header (mpm->message, &header);
mu_header_get_value (header, MU_HEADER_STATUS,
hdr_status, sizeof hdr_status, NULL);
mu_string_to_flags (hdr_status, &mpm->attr_flags);
}
*pflags = mpm->attr_flags;
return 0;
}
int
restore_sender (mu_message_t msg, mbox_data_t mud)
{
mu_header_t hdr;
char *from = NULL;
int rc = 0;
if (mu_message_get_header (msg, &hdr) == 0)
mu_header_aget_value (hdr, MU_HEADER_FROM, &from);
if (from)
{
int status;
mu_address_t addr;
status = mu_address_create (&addr, from);
free (from);
from = NULL;
if (status == 0)
mu_address_aget_email (addr, 1, &from);
mu_address_destroy (&addr);
}
if (!from)
{
from = strdup (PACKAGE);
if (!from)
return ENOMEM;
}
mud->sender = strdup (from);
if (!mud->sender)
rc = ENOMEM;
free (from);
return rc;
}
int
sieve_action_vacation (mu_sieve_machine_t mach, mu_list_t args, mu_list_t tags)
{
int rc;
char *text, *from;
mu_sieve_value_t *val;
mu_message_t msg;
mu_header_t hdr;
char *my_address = mu_sieve_get_daemon_email (mach);
if (diag (mach))
return 0;
val = mu_sieve_value_get (args, 0);
if (!val)
{
mu_sieve_error (mach, _("cannot get text!"));
mu_sieve_abort (mach);
}
else
text = val->v.string;
msg = mu_sieve_get_message (mach);
mu_message_get_header (msg, &hdr);
if (mu_sieve_tag_lookup (tags, "sender", &val))
{
/* Debugging hook: :sender sets fake reply address */
from = strdup (val->v.string);
if (!from)
{
mu_sieve_error (mach, "%lu: %s",
(unsigned long) mu_sieve_get_message_num (mach),
mu_strerror (ENOMEM));
mu_sieve_abort (mach);
}
}
else if (mu_sieve_get_message_sender (msg, &from))
{
mu_sieve_error (mach,
_("%lu: cannot get sender address"),
(unsigned long) mu_sieve_get_message_num (mach));
mu_sieve_abort (mach);
}
if (mu_sieve_tag_lookup (tags, "aliases", &val)
&& match_addresses (hdr, val, &my_address) == 0)
return 0;
if (noreply_address_p (mach, tags, from)
|| bulk_precedence_p (hdr)
|| check_db (mach, tags, from))
{
free (from);
return 0;
}
rc = vacation_reply (mach, tags, msg, text, from, my_address);
free (from);
if (rc == -1)
mu_sieve_abort (mach);
return rc;
}
/* Handler for the timestamp test */
static int
timestamp_test (mu_sieve_machine_t mach, mu_list_t args, mu_list_t tags)
{
mu_sieve_value_t *h, *v;
mu_header_t hdr;
char *val;
time_t now = time (NULL);
time_t tlimit, tval;
int rc;
if (mu_sieve_get_debug_level (mach) & MU_SIEVE_DEBUG_TRACE)
{
mu_sieve_locus_t locus;
mu_sieve_get_locus (mach, &locus);
mu_sieve_debug (mach, "%s:%lu: TIMESTAMP\n",
locus.source_file,
(unsigned long) locus.source_line);
}
/* Retrieve required arguments: */
/* First argument: header name */
h = mu_sieve_value_get (args, 0);
if (!h)
{
mu_sieve_arg_error (mach, 1);
mu_sieve_abort (mach);
}
/* Second argument: date displacement */
v = mu_sieve_value_get (args, 1);
if (!v)
{
mu_sieve_arg_error (mach, 2);
mu_sieve_abort (mach);
}
if (mu_parse_date (v->v.string, &tlimit, &now))
{
mu_sieve_error (mach, _("cannot parse date specification (%s)"),
v->v.string);
mu_sieve_abort (mach);
}
rc = mu_message_get_header (mu_sieve_get_message (mach), &hdr);
if (rc)
{
mu_sieve_error (mach, "mu_message_get_header: %s", mu_strerror (rc));
mu_sieve_abort (mach);
}
if (mu_header_aget_value (hdr, h->v.string, &val))
return 0;
if (mu_parse_date (val, &tval, &now))
{
mu_sieve_error (mach,
"cannot parse header date specification (%s)",
val);
free (val);
mu_sieve_abort (mach);
}
free (val);
rc = tval > tlimit;
if (mu_sieve_tag_lookup (tags, "before", NULL))
rc = !rc;
return rc;
}
static void
vacation_subject (mu_sieve_machine_t mach, mu_list_t tags,
mu_message_t msg, mu_header_t newhdr)
{
mu_sieve_value_t *arg;
char *value;
char *subject;
int subject_allocated = 0;
mu_header_t hdr;
if (mu_sieve_tag_lookup (tags, "subject", &arg))
subject = arg->v.string;
else if (mu_message_get_header (msg, &hdr) == 0
&& mu_header_aget_value_unfold (hdr, MU_HEADER_SUBJECT,
&value) == 0)
{
char *p;
int rc = mu_rfc2047_decode (MU_SIEVE_CHARSET, value, &p);
subject_allocated = 1;
if (rc)
{
subject = value;
value = NULL;
}
else
{
subject = p;
}
if (mu_sieve_tag_lookup (tags, "reply_regex", &arg))
{
char *err = NULL;
rc = mu_unre_set_regex (arg->v.string, 0, &err);
if (rc)
{
mu_sieve_error (mach,
_("%lu: cannot compile reply prefix regexp: %s: %s"),
(unsigned long) mu_sieve_get_message_num (mach),
mu_strerror (rc),
err ? err : "");
}
}
if (mu_unre_subject (subject, NULL))
re_subject (mach, tags, &subject);
free (value);
}
else
subject = "Re: Your mail";
if (mu_rfc2047_encode (MU_SIEVE_CHARSET, "quoted-printable",
subject, &value))
mu_header_set_value (newhdr, MU_HEADER_SUBJECT, subject, 0);
else
{
mu_header_set_value (newhdr, MU_HEADER_SUBJECT, value, 0);
free (value);
}
if (subject_allocated)
free (subject);
}
/* Generate and send the reply message */
static int
vacation_reply (mu_sieve_machine_t mach, mu_list_t tags, mu_message_t msg,
char *text, char *to, char *from)
{
mu_mime_t mime = NULL;
mu_message_t newmsg;
mu_header_t newhdr;
mu_address_t to_addr = NULL, from_addr = NULL;
char *value;
mu_mailer_t mailer;
int rc;
if (mu_sieve_tag_lookup (tags, "file", NULL))
{
mu_stream_t instr;
rc = mu_mapfile_stream_create (&instr, text, MU_STREAM_READ);
if (rc)
{
mu_sieve_error (mach,
_("%lu: cannot open message file %s: %s"),
(unsigned long) mu_sieve_get_message_num (mach),
text,
mu_strerror (rc));
return -1;
}
rc = mu_stream_to_message (instr, &newmsg);
mu_stream_unref (instr);
if (rc)
{
mu_sieve_error (mach,
_("%lu: cannot read message from file %s: %s"),
(unsigned long) mu_sieve_get_message_num (mach),
text,
mu_strerror (rc));
return -1;
}
}
else
{
if (build_mime (mach, tags, &mime, msg, text))
return -1;
mu_mime_get_message (mime, &newmsg);
mu_message_unref (newmsg);
mu_message_get_header (newmsg, &newhdr);
}
rc = mu_address_create (&to_addr, to);
if (rc)
{
mu_sieve_error (mach,
_("%lu: cannot create recipient address <%s>: %s"),
(unsigned long) mu_sieve_get_message_num (mach),
from, mu_strerror (rc));
}
else
{
mu_header_set_value (newhdr, MU_HEADER_TO, to, 0);
vacation_subject (mach, tags, msg, newhdr);
if (from)
{
if (mu_address_create (&from_addr, from))
from_addr = NULL;
}
else
{
from_addr = NULL;
}
if (mu_rfc2822_in_reply_to (msg, &value) == 0)
{
mu_header_set_value (newhdr, MU_HEADER_IN_REPLY_TO, value, 1);
free (value);
}
if (mu_rfc2822_references (msg, &value) == 0)
{
mu_header_set_value (newhdr, MU_HEADER_REFERENCES, value, 1);
free (value);
}
mailer = mu_sieve_get_mailer (mach);
if (mailer)
{
rc = mu_mailer_send_message (mailer, newmsg, from_addr, to_addr);
}
else
rc = MU_ERR_FAILURE;
}
mu_address_destroy (&to_addr);
mu_address_destroy (&from_addr);
mu_mime_destroy (&mime);
return rc;
}
int
main (int argc, char **argv)
{
int i;
char *host = NULL;
char *infile = NULL;
char *port = NULL;
int tls = 0;
int raw = 1;
int flags = 0;
mu_stream_t stream;
mu_smtp_t smtp;
mu_stream_t instr;
char *from = NULL;
mu_list_t rcpt_list = NULL;
mu_list_t meth_list = NULL;
mu_list_t skiphdr_list = NULL;
struct mu_sockaddr *sa;
struct mu_sockaddr_hints hints;
mu_set_program_name (argv[0]);
mu_stdstream_setup (MU_STDSTREAM_RESET_NONE);
if (argc < 2)
usage ();
memset (&hints, 0, sizeof (hints));
hints.flags = MU_AH_DETECT_FAMILY;
hints.port = 25;
hints.protocol = IPPROTO_TCP;
hints.socktype = SOCK_STREAM;
MU_ASSERT (mu_smtp_create (&smtp));
for (i = 1; i < argc; i++)
{
if (strncmp (argv[i], "port=", 5) == 0)
port = argv[i] + 5;
else if (strncmp (argv[i], "family=", 7) == 0)
{
hints.flags &= ~MU_AH_DETECT_FAMILY;
switch (argv[i][7])
{
case '4':
hints.family = AF_INET;
break;
case '6':
hints.family = AF_INET6;
break;
default:
mu_error ("invalid family name: %s", argv[i]+7);
exit (1);
}
}
else if (strncmp (argv[i], "trace=", 6) == 0)
{
char *arg = argv[i] + 6;
if (mu_isdigit (arg[0]))
mu_smtp_trace (smtp, atoi (argv[i] + 6) ?
MU_SMTP_TRACE_SET : MU_SMTP_TRACE_CLR);
else
{
mu_smtp_trace (smtp, MU_SMTP_TRACE_SET);
if (strcmp (arg, "secure") == 0)
mu_smtp_trace_mask (smtp, MU_SMTP_TRACE_SET,
MU_XSCRIPT_SECURE);
else if (strcmp (arg, "payload") == 0)
mu_smtp_trace_mask (smtp, MU_SMTP_TRACE_SET,
MU_XSCRIPT_PAYLOAD);
}
}
else if (strncmp (argv[i], "tls=", 4) == 0)
tls = atoi (argv[i] + 4);
else if (strncmp (argv[i], "domain=", 7) == 0)
MU_ASSERT (mu_smtp_set_param (smtp, MU_SMTP_PARAM_DOMAIN,
argv[i] + 7));
else if (strncmp (argv[i], "user="******"pass="******"service=", 8) == 0)
MU_ASSERT (mu_smtp_set_param (smtp, MU_SMTP_PARAM_SERVICE,
argv[i] + 8));
else if (strncmp (argv[i], "realm=", 6) == 0)
MU_ASSERT (mu_smtp_set_param (smtp, MU_SMTP_PARAM_REALM,
argv[i] + 6));
else if (strncmp (argv[i], "host=", 5) == 0)
MU_ASSERT (mu_smtp_set_param (smtp, MU_SMTP_PARAM_HOST,
argv[i] + 5));
else if (strncmp (argv[i], "url=", 4) == 0)
MU_ASSERT (mu_smtp_set_param (smtp, MU_SMTP_PARAM_URL,
argv[i] + 4));
else if (strncmp (argv[i], "input=", 6) == 0)
infile = argv[i] + 6;
else if (strncmp (argv[i], "raw=", 4) == 0)
raw = atoi (argv[i] + 4);
else if (strncmp (argv[i], "rcpt=", 5) == 0)
{
if (!rcpt_list)
MU_ASSERT (mu_list_create (&rcpt_list));
MU_ASSERT (mu_list_append (rcpt_list, argv[i] + 5));
}
else if (strncmp (argv[i], "from=", 5) == 0)
from = argv[i] + 5;
else if (strncmp (argv[i], "auth=", 5) == 0)
update_list (&meth_list, argv[i] + 5);
else if (strncmp (argv[i], "skiphdr=", 8) == 0)
{
update_list (&skiphdr_list, argv[i] + 8);
raw = 0;
}
else if (host)
{
mu_error ("server name already given: %s, new name %s?",
host, argv[i]);
exit (1);
}
else
host = argv[i];
}
if (!host)
usage ();
if (!raw)
flags = MU_STREAM_SEEK;
if (infile)
MU_ASSERT (mu_file_stream_create (&instr, infile, MU_STREAM_READ|flags));
else
MU_ASSERT (mu_stdio_stream_create (&instr, MU_STDIN_FD, flags));
host = argv[1];
MU_ASSERT (mu_sockaddr_from_node (&sa, host, port, &hints));
MU_ASSERT (mu_tcp_stream_create_from_sa (&stream, sa, NULL, MU_STREAM_RDWR));
mu_smtp_set_carrier (smtp, stream);
mu_stream_unref (stream);
if (!from)
{
from = getenv ("USER");
if (!from)
{
mu_error ("cannot determine sender name");
exit (1);
}
}
if (raw && !rcpt_list)
{
mu_error ("no recipients");
exit (1);
}
MU_ASSERT (mu_smtp_open (smtp));
MU_ASSERT (mu_smtp_ehlo (smtp));
if (tls && mu_smtp_capa_test (smtp, "STARTTLS", NULL) == 0)
{
MU_ASSERT (mu_smtp_starttls (smtp));
MU_ASSERT (mu_smtp_ehlo (smtp));
}
if (meth_list)
{
int status;
MU_ASSERT (mu_smtp_add_auth_mech_list (smtp, meth_list));
status = mu_smtp_auth (smtp);
switch (status)
{
case 0:
MU_ASSERT (mu_smtp_ehlo (smtp));
break;
case ENOSYS:
case MU_ERR_NOENT:
/* Ok, skip it */
break;
default:
mu_error ("authentication failed: %s", mu_strerror (status));
exit (1);
}
}
MU_ASSERT (mu_smtp_mail_basic (smtp, from, NULL));
mu_list_foreach (rcpt_list, send_rcpt_command, smtp);
if (raw)
{
/* Raw sending mode: send from the stream directly */
MU_ASSERT (mu_smtp_send_stream (smtp, instr));
}
else
{
/* Message (standard) sending mode: send a MU message. */
mu_message_t msg;
mu_stream_t ostr, bstr;
mu_header_t hdr;
mu_iterator_t itr;
mu_body_t body;
if (skiphdr_list)
mu_list_set_comparator (skiphdr_list, headercmp);
MU_ASSERT (mu_stream_to_message (instr, &msg));
mu_stream_unref (instr);
MU_ASSERT (mu_smtp_data (smtp, &ostr));
MU_ASSERT (mu_message_get_header (msg, &hdr));
MU_ASSERT (mu_header_get_iterator (hdr, &itr));
for (mu_iterator_first (itr); !mu_iterator_is_done (itr);
mu_iterator_next (itr))
{
const char *name;
void *value;
mu_iterator_current_kv (itr, (void*) &name, &value);
if (mu_list_locate (skiphdr_list, (void*) name, NULL) == 0)
continue;
mu_stream_printf (ostr, "%s: %s\n", name, (char*)value);
}
mu_iterator_destroy (&itr);
MU_ASSERT (mu_stream_write (ostr, "\n", 1, NULL));
MU_ASSERT (mu_message_get_body (msg, &body));
MU_ASSERT (mu_body_get_streamref (body, &bstr));
MU_ASSERT (mu_stream_copy (ostr, bstr, 0, NULL));
mu_stream_destroy (&bstr);
mu_stream_close (ostr);
mu_stream_destroy (&ostr);
}
MU_ASSERT (mu_smtp_dot (smtp));
MU_ASSERT (mu_smtp_quit (smtp));
mu_smtp_destroy (&smtp);
mu_stream_close (instr);
mu_stream_destroy (&instr);
return 0;
}
/* 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
reply0 (msgset_t *mspec, mu_message_t msg, void *data)
{
mu_header_t hdr;
compose_env_t env;
int status;
char *str;
set_cursor (mspec->msg_part[0]);
compose_init (&env);
mu_message_get_header (msg, &hdr);
compose_header_set (&env, MU_HEADER_TO,
util_get_sender (mspec->msg_part[0], 0),
COMPOSE_SINGLE_LINE);
if (*(int*) data) /* reply starts with a lowercase */
{
/* Add all recepients of the originate letter */
mu_address_t addr = NULL;
size_t i, count = 0;
if (mu_header_aget_value (hdr, MU_HEADER_TO, &str) == 0)
{
mu_address_create (&addr, str);
free (str);
mu_address_get_count (addr, &count);
}
/* Make sure we do not include our alternate names */
for (i = 1; i <= count; i++)
{
const char *email;
if (mu_address_sget_email (addr, i, &email) || email == NULL)
continue;
if ((mailvar_get (NULL, "metoo", mailvar_type_boolean, 0) == 0)
|| !mail_is_my_name (email))
compose_header_set (&env, MU_HEADER_TO,
email,
COMPOSE_SINGLE_LINE);
}
mu_address_destroy (&addr);
/* Finally, add any Ccs */
if (mu_header_aget_value (hdr, MU_HEADER_CC, &str) == 0)
compose_header_set (&env, MU_HEADER_TO, str, COMPOSE_SINGLE_LINE);
}
if (mu_header_aget_value (hdr, MU_HEADER_SUBJECT, &str) == 0)
{
char *p = NULL;
if (mu_unre_subject (str, NULL))
util_strcat (&p, util_reply_prefix ());
util_strcat (&p, str);
free (str);
compose_header_set (&env, MU_HEADER_SUBJECT, p, COMPOSE_REPLACE);
free (p);
}
else
compose_header_set (&env, MU_HEADER_SUBJECT, "", COMPOSE_REPLACE);
mu_printf ("To: %s\n",
compose_header_get (&env, MU_HEADER_TO, ""));
str = compose_header_get (&env, MU_HEADER_CC, NULL);
if (str)
mu_printf ("Cc: %s\n", str);
mu_printf ("Subject: %s\n\n",
compose_header_get (&env, MU_HEADER_SUBJECT, ""));
make_in_reply_to (&env, msg);
make_references (&env, msg);
status = mail_send0 (&env,
mailvar_get (NULL, "byname", mailvar_type_boolean, 0)
== 0);
compose_destroy (&env);
return status;
}
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);
}
}
/* Syntax: deleteheader [:index <fieldno: number> [:last]]
[COMPARATOR] [MATCH-TYPE]
<field-name: string>
[<value-patterns: string-list>]
*/
int
sieve_deleteheader (mu_sieve_machine_t mach, mu_list_t args, mu_list_t tags)
{
mu_sieve_value_t *val;
const char *field_name;
const char *field_pattern;
mu_message_t msg;
mu_header_t hdr;
int rc;
mu_sieve_comparator_t comp;
mu_iterator_t itr;
unsigned long i, idx = 0;
val = mu_sieve_value_get (args, 0);
if (!val)
{
mu_sieve_error (mach, "%lu: %s",
(unsigned long) mu_sieve_get_message_num (mach),
_("cannot get field name"));
mu_sieve_abort (mach);
}
field_name = val->v.string;
val = mu_sieve_value_get (args, 1);
if (!val)
{
field_pattern = NULL;
mu_sieve_log_action (mach, "DELETEHEADER", "%s", field_name);
}
else
{
switch (val->type)
{
case SVT_STRING_LIST:
if (mu_list_get (val->v.list, 0, (void**)&field_pattern))
{
mu_sieve_error (mach, "%lu: %s",
(unsigned long) mu_sieve_get_message_num (mach),
_("cannot get list item"));
mu_sieve_abort (mach);
}
mu_sieve_log_action (mach, "DELETEHEADER", "%s: (regexp)",
field_name);
break;
case SVT_STRING:
field_pattern = val->v.string;
mu_sieve_log_action (mach, "DELETEHEADER", "%s: %s", field_name,
field_pattern);
break;
default:
mu_sieve_error (mach, "%lu: %s: %d",
(unsigned long) mu_sieve_get_message_num (mach),
_("unexpected value type"), val->type);
mu_sieve_abort (mach);
}
}
if (mu_sieve_is_dry_run (mach))
return 0;
msg = mu_sieve_get_message (mach);
rc = mu_message_get_header (msg, &hdr);
if (rc)
{
mu_sieve_error (mach, "%lu: %s: %s",
(unsigned long) mu_sieve_get_message_num (mach),
_("cannot get message header"),
mu_strerror (rc));
mu_sieve_abort (mach);
}
mu_header_get_iterator (hdr, &itr);
if (mu_sieve_tag_lookup (tags, "last", NULL))
{
int backwards = 1;
mu_iterator_ctl (itr, mu_itrctl_set_direction, &backwards);
}
comp = mu_sieve_get_comparator (mach, tags);
if (mu_sieve_tag_lookup (tags, "index", &val))
idx = val->v.number;
for (i = 0, mu_iterator_first (itr); !mu_iterator_is_done (itr);
mu_iterator_next (itr))
{
const char *fn, *fv;
mu_iterator_current_kv (itr, (const void **)&fn, (void **)&fv);
if (strcmp (field_name, fn))
continue;
if (idx && ++i < idx)
continue;
if (field_pattern)
{
if (comp (field_pattern, fv))
mu_iterator_ctl (itr, mu_itrctl_delete, NULL);
}
else
mu_iterator_ctl (itr, mu_itrctl_delete, NULL);
if (idx)
break;
}
mu_iterator_destroy (&itr);
return 0;
}
int
main (int argc, char **argv)
{
mu_mailbox_t mbox = NULL;
size_t i;
size_t count = 0;
char *mailbox_name;
int debug = 0;
for (i = 1; i < argc; i++)
{
if (strcmp (argv[i], "-d") == 0)
debug = 1;
else if (strcmp (argv[i], "-p") == 0)
print_attachments = 1;
else if (strcmp (argv[i], "-i") == 0)
{
if (++i == argc)
{
mu_error ("-i requires argument");
exit (1);
}
indent_level = strtoul (argv[i], NULL, 0);
}
else if (strcmp (argv[i], "-c") == 0)
{
if (++i == argc)
{
mu_error ("-c requires argument");
exit (1);
}
charset = argv[i];
}
else
break;
}
mailbox_name = argv[i];
/* Registration. */
mu_registrar_record (mu_imap_record);
mu_registrar_record (mu_pop_record);
mu_registrar_record (mu_mbox_record);
mu_registrar_set_default_record (mu_mbox_record);
MU_ASSERT (mu_mailbox_create_default (&mbox, mailbox_name));
/* Debugging trace. */
if (debug)
{
mu_debug_set_category_level (MU_DEBCAT_MAILBOX,
MU_DEBUG_LEVEL_UPTO (MU_DEBUG_PROT));
}
/* Open the mailbox for reading only. */
MU_ASSERT (mu_mailbox_open (mbox, MU_STREAM_READ));
/* Iterate through the entire message set. */
MU_ASSERT (mu_mailbox_messages_count (mbox, &count));
for (i = 1; i <= count; ++i)
{
mu_message_t msg;
mu_header_t hdr;
size_t nparts;
size_t msize, nlines;
MU_ASSERT (mu_mailbox_get_message (mbox, i, &msg));
MU_ASSERT (mu_message_size (msg, &msize));
MU_ASSERT (mu_message_lines (msg, &nlines));
MU_ASSERT (mu_message_get_header (msg, &hdr));
if (mu_header_sget_value (hdr, MU_HEADER_FROM, &from))
from = "";
if (mu_header_sget_value (hdr, MU_HEADER_SUBJECT, &subject))
subject = "";
printf ("Message: %lu\n", (unsigned long) i);
printf ("From: %s\n", from);
printf ("Subject: %s\n", subject);
MU_ASSERT (mu_message_get_num_parts (msg, &nparts));
printf ("Number of parts in message - %lu\n",
(unsigned long) nparts);
printf ("Total message size - %lu/%lu\n",
(unsigned long) msize, (unsigned long) nlines);
message_display_parts (msg, 0);
}
mu_mailbox_close (mbox);
mu_mailbox_destroy (&mbox);
return 0;
}
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;
}
oo\n\
";
int
main (int argc, char **argv)
{
int i;
char *p;
mu_message_t msg;
mu_stream_t stream = NULL;
mu_header_t hdr;
mu_body_t body;
mu_set_program_name (argv[0]);
mu_static_memory_stream_create (&stream, text, strlen (text));
assert (mu_stream_to_message (stream, &msg) == 0);
mu_stream_unref (stream);
assert (mu_message_get_header (msg, &hdr) == 0);
assert (mu_message_get_body (msg, &body) == 0);
assert (mu_body_get_streamref (body, &stream) == 0);
assert (mu_stream_seek (stream, 0, MU_SEEK_END, NULL) == 0);
for (i = 1; i < argc; i++)
{
if (strcmp (argv[i], "-h") == 0)
{
mu_printf ("usage: %s [-a HDR:VAL] [-t TEXT]\n", mu_program_name);
return 0;
}
if (strcmp (argv[i], "-a") == 0)
{
i++;
assert (argv[i] != NULL);
p = strchr (argv[i], ':');
assert (p != NULL);
*p++ = 0;
while (*p && mu_isspace (*p))
p++;
assert (mu_header_set_value (hdr, argv[i], p, 1) == 0);
}
else if (strcmp (argv[i], "-l") == 0)
{
mu_off_t off;
int whence = MU_SEEK_SET;
i++;
assert (argv[i] != NULL);
off = strtol (argv[i], &p, 10);
assert (*p == 0);
if (off < 0)
whence = MU_SEEK_END;
assert (mu_stream_seek (stream, off, whence, NULL) == 0);
}
else if (strcmp (argv[i], "-t") == 0)
{
mu_wordsplit_t ws;
i++;
assert (argv[i] != NULL);
if (mu_wordsplit (argv[i], &ws,
MU_WRDSF_NOSPLIT | MU_WRDSF_DEFFLAGS))
{
mu_error ("mu_wordsplit: %s", mu_wordsplit_strerror (&ws));
exit (1);
}
else
assert (mu_stream_write (stream, ws.ws_wordv[0],
strlen (ws.ws_wordv[0]), NULL) == 0);
mu_wordsplit_free (&ws);
}
else
mu_error ("ignoring unknown argument %s", argv[i]);
}
mu_stream_unref (stream);
assert (mu_message_get_streamref (msg, &stream) == 0);
assert (mu_stream_copy (mu_strout, stream, 0, NULL) == 0);
mu_stream_unref (stream);
return 0;
}
int
main (int argc, const char **argv)
{
char *from;
char *subject;
mu_mailbox_t mbox;
size_t msgno, total = 0;
int status;
/* Register the formats. */
mu_register_all_mbox_formats ();
status = mu_mailbox_create_default (&mbox, argv[1]);
if (status != 0)
{
mu_error ("mu_mailbox_create: %s", mu_strerror (status));
exit (EXIT_FAILURE);
}
status = mu_mailbox_open (mbox, MU_STREAM_READ);
if (status != 0)
{
mu_error ("mu_mailbox_open: %s", mu_strerror (status));
exit (EXIT_FAILURE);
}
mu_mailbox_messages_count (mbox, &total);
for (msgno = 1; msgno <= total; msgno++)
{
mu_message_t msg;
mu_header_t hdr;
if ((status = mu_mailbox_get_message (mbox, msgno, &msg)) != 0
|| (status = mu_message_get_header (msg, &hdr)) != 0)
{
mu_error ("Error message: %s", mu_strerror (status));
exit (EXIT_FAILURE);
}
if (mu_header_aget_value (hdr, MU_HEADER_FROM, &from))
from = strdup ("(NO FROM)");
if (mu_header_aget_value (hdr, MU_HEADER_SUBJECT, &subject))
subject = strdup ("(NO SUBJECT)");
printf ("%s\t%s\n", from, subject);
free (from);
free (subject);
}
status = mu_mailbox_close (mbox);
if (status != 0)
{
mu_error ("mu_mailbox_close: %s", mu_strerror (status));
exit (EXIT_FAILURE);
}
mu_mailbox_destroy (&mbox);
return 0;
}
int
message_finalize (mu_message_t msg, int warn)
{
mu_header_t header = NULL;
int have_to;
char *value = NULL;
mu_message_get_header (msg, &header);
if (warn && from_person)
{
struct passwd *pwd = getpwuid (getuid ());
char *warn = malloc (strlen (pwd->pw_name) + 1 +
sizeof (SENDER_WARNING));
if (warn == NULL)
{
mu_error ("%s: not enough memory", progname);
return 1;
}
sprintf (warn, "%s %s", pwd->pw_name, SENDER_WARNING);
mu_header_set_value (header, "X-Authentication-Warning", warn, 0);
free (warn);
}
have_to = mu_header_aget_value (header, MU_HEADER_TO, &value) == 0;
if (read_recipients)
{
if (value)
{
if (add_recipient (value))
{
mu_error ("%s: bad address %s", progname, value);
return 1;
}
free (value);
}
if (mu_header_aget_value (header, MU_HEADER_CC, &value) == 0)
{
if (add_recipient (value))
{
mu_error ("%s: bad address %s", progname, value);
return 1;
}
free (value);
}
if (mu_header_aget_value (header, MU_HEADER_BCC, &value) == 0)
{
if (add_recipient (value))
{
mu_error ("%s: bad address %s", progname, value);
return 1;
}
free (value);
mu_header_set_value (header, MU_HEADER_BCC, NULL, 1);
}
}
if (!have_to)
{
size_t n;
int c;
c = mu_address_to_string (recipients, NULL, 0, &n);
if (c)
{
mu_error ("%s: mu_address_to_string failure: %s",
progname, mu_strerror (c));
return 1;
}
value = malloc (n + 1);
if (!value)
{
mu_error ("%s: not enough memory", progname);
return 1;
}
mu_address_to_string (recipients, value, n + 1, &n);
mu_header_set_value (header, MU_HEADER_TO, value, 1);
free (value);
}
return 0;
}
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;
}
