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;
}
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;
const char *value = NULL;
if ((rc = mu_header_sget_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);
return rc;
}
static int
_mh_prop_setval (struct _mu_property *prop, const char *key,
const char *val, int overwrite)
{
struct mu_mh_prop *mhprop = prop->_prop_init_data;
mu_header_t header = prop->_prop_data;
if (!header)
{
int rc;
if ((rc = mu_header_create (&header, NULL, 0)) != 0)
{
mu_error (_("cannot create context %s: %s"),
mhprop->filename, mu_strerror (rc));
return 1;
}
prop->_prop_data = header;
}
return mu_header_set_value (header, key, val, overwrite);
}
/* 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;
}
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);
}
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
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;
}
