static int
top0 (msgset_t *mspec, mu_message_t msg, void *data)
{
mu_stream_t stream;
char *buf = NULL;
size_t size = 0, n;
int lines;
if (mailvar_get (&lines, "toplines", mailvar_type_number, 1)
|| lines < 0)
return 1;
mu_message_get_streamref (msg, &stream);
for (; lines > 0; lines--)
{
int status = mu_stream_getline (stream, &buf, &size, &n);
if (status != 0 || n == 0)
break;
mu_printf ("%s", buf);
}
free (buf);
mu_stream_destroy (&stream);
set_cursor (mspec->msg_part[0]);
util_mark_read (msg);
return 0;
}
/* %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
mail_reply (int argc, char **argv)
{
int lower = mu_islower (argv[0][0]);
if (mailvar_get (NULL, "flipr", mailvar_type_boolean, 0) == 0)
lower = !lower;
return util_foreach_msg (argc, argv, MSG_NODELETED, reply0, &lower);
}
char *
alias_expand (const char *name)
{
alias_t al;
mu_list_t list;
if (mailvar_get (NULL, "recursivealiases", mailvar_type_boolean, 0) == 0)
{
char *s;
mu_list_t origlist;
int status = mu_list_create (&list);
if (status)
{
mu_diag_funcall (MU_DIAG_ERROR, "mu_list_create", NULL, status);
return NULL;
}
status = mu_list_create (&origlist);
if (status)
{
mu_list_destroy (&origlist);
mu_diag_funcall (MU_DIAG_ERROR, "mu_list_create", NULL, status);
return NULL;
}
mu_list_set_comparator (list, string_comp);
mu_list_set_comparator (origlist, string_comp);
recursive_alias_expand (name, list, origlist);
s = util_slist_to_string (list, ",");
mu_list_destroy (&origlist);
mu_list_destroy (&list);
return s;
}
if ((al = alias_lookup (name)) == NULL)
return NULL;
return util_slist_to_string (al->list, ",");
}
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;
}
int
mail_file (int argc, char **argv)
{
if (argc == 1)
{
mail_summary (0, NULL);
}
else if (argc == 2)
{
/* switch folders */
char *pname;
mu_url_t url;
mu_mailbox_t newbox = NULL;
char *name = mail_expand_name (argv[1]);
int status;
if (!name)
return 1;
if ((status = mu_mailbox_create_default (&newbox, name)) != 0
|| (status = mu_mailbox_open (newbox, MU_STREAM_RDWR)) != 0)
{
mu_mailbox_destroy (&newbox);
util_error(_("Cannot open mailbox %s: %s"), name, mu_strerror (status));
free (name);
return 1;
}
free (name); /* won't need it any more */
page_invalidate (1); /* Invalidate current page map */
mu_mailbox_get_url (mbox, &url);
pname = strdup (mu_url_to_string (url));
if (mail_mbox_close ())
{
if (pname)
free (pname);
mu_mailbox_close (newbox);
mu_mailbox_destroy (&newbox);
return 1;
}
if (prev_name)
free (prev_name);
prev_name = pname;
mbox = newbox;
mu_mailbox_messages_count (mbox, &total);
set_cursor (1);
if (mailvar_get (NULL, "header", mailvar_type_boolean, 0) == 0)
{
util_do_command ("summary");
util_do_command ("headers");
}
return 0;
}
else
{
util_error(_("%s takes only one argument"), argv[0]);
}
return 1;
}
/* %f */
static char *
hdr_from (struct header_call_args *args, void *data)
{
char *from = NULL;
if (mailvar_get (NULL, "fromfield", mailvar_type_boolean, 0) == 0)
{
mu_header_t hdr;
mu_message_get_header (args->msg, &hdr);
if (mu_header_aget_value_unfold (hdr, MU_HEADER_FROM, &from) == 0)
{
mu_address_t address = NULL;
if (mu_address_create (&address, from) == 0)
{
char *name;
const char *email;
if (mu_address_sget_email (address, 1, &email) == 0)
{
if (mailvar_get (NULL, "showto",
mailvar_type_boolean, 0) == 0
&& mail_is_my_name (email))
{
char *tmp;
if (mu_header_aget_value_unfold (hdr, MU_HEADER_TO,
&tmp) == 0)
{
mu_address_t addr_to;
if (mu_address_create (&addr_to, tmp) == 0)
{
mu_address_destroy (&address);
address = addr_to;
}
free (tmp);
}
}
}
if ((mu_address_aget_personal (address, 1, &name) == 0
&& name)
|| (mu_address_aget_email (address, 1, &name) == 0
&& name))
{
free (from);
from = name;
}
mu_address_destroy (&address);
}
}
util_rfc2047_decode (&from);
}
else
{
mu_envelope_t env = NULL;
const char *sender = "";
if (mu_message_get_envelope (args->msg, &env) == 0)
mu_envelope_sget_sender (env, &sender);
from = strdup (sender);
}
header_buf_string (args, from);
free (from);
return args->buf;
}
