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; }