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 */
}
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
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;
}
static int
copy_header (mu_sieve_machine_t mach,
mu_header_t to_hdr, char *to, mu_header_t from_hdr, char *from)
{
int rc;
char *value = NULL;
if ((rc = mu_header_aget_value (from_hdr, from, &value)))
{
mu_sieve_error (mach, _("cannot get `%s:' header: %s"),
from, mu_strerror (rc));
return rc;
}
rc = mu_header_set_value (to_hdr, to, value, 0);
free (value);
return rc;
}
static int
_count_items (void *item, void *data)
{
char *name = item;
struct val_ctr *vp = data;
char *val;
mu_address_t addr;
size_t count = 0;
if (mu_header_aget_value (vp->hdr, name, &val))
return 0;
if (mu_address_create (&addr, val) == 0)
{
mu_address_get_count (addr, &count);
mu_address_destroy (&addr);
vp->count += count;
}
free (val);
return vp->count >= vp->limit;
}
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
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;
}
/* 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;
}
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, 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;
}
