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