X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=alias.c;h=68afc256a0c64e24632a477113dbef4a91f6a6be;hp=835d55a4af6747829b9a98702712022ff6eaaa7c;hb=916e4872caf252a5850e64f79427b9dd7808435d;hpb=91d0c04349c9345f0ee29a61cc18dfc144b60edc diff --git a/alias.c b/alias.c index 835d55a..68afc25 100644 --- a/alias.c +++ b/alias.c @@ -1,3 +1,21 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or (at + * your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + * + * Copyright © 2006 Pierre Habouzit + */ /* * Copyright notice from original mutt: * Copyright (C) 1996-2002 Michael R. Elkins @@ -7,143 +25,144 @@ * please see the file GPL in the top level source directory. */ -#if HAVE_CONFIG_H -# include "config.h" -#endif +#include -#include -#include +#include -#include -#include -#include -#include -#include -#include +#include +#include +#include -#include "lib/rx.h" -#include "lib/debug.h" - -#include "mutt.h" -#include "enter.h" -#include "mutt_curses.h" +#include "alias.h" #include "mutt_idna.h" -#include "mutt_menu.h" #include "sort.h" +char *AliasFmt; +char *AliasFile; +alias_t *Aliases; +rx_t GecosMask; + #define RSORT(x) (SortAlias & SORT_REVERSE) ? -x : x static struct mapping_t AliasHelp[] = { - {N_("Exit"), OP_EXIT}, - {N_("Del"), OP_DELETE}, - {N_("Undel"), OP_UNDELETE}, - {N_("Select"), OP_GENERIC_SELECT_ENTRY}, - {N_("Help"), OP_HELP}, - {NULL, OP_NULL} + {N_("Exit"), OP_EXIT}, + {N_("Del"), OP_DELETE}, + {N_("Undel"), OP_UNDELETE}, + {N_("Select"), OP_GENERIC_SELECT_ENTRY}, + {N_("Help"), OP_HELP}, + {NULL, OP_NULL} }; -ADDRESS *mutt_lookup_alias (const char *s) +static void mutt_alias_menu(char *, size_t, alias_t *); + +const address_t *alias_lookup(const char *s) { - ALIAS *t = Aliases; + alias_t *list; - for (; t; t = t->next) - if (!m_strcasecmp(s, t->name)) - return (t->addr); - return (NULL); /* no such alias */ + for (list = Aliases; list; list = list->next) { + if (!m_strcasecmp(s, list->name)) + return list->addr; + } + + return NULL; } -static ADDRESS *mutt_expand_aliases_r (ADDRESS * a, LIST ** expn) +/* This routine looks to see if the user has an alias defined for the given + address. */ +const address_t *alias_reverse_lookup(const address_t *a) { - ADDRESS *head = NULL, *last = NULL, *t, *w; - LIST *u; - char i; - const char *fqdn; - - while (a) { - if (!a->group && !a->personal && a->mailbox - && strchr (a->mailbox, '@') == NULL) { - t = mutt_lookup_alias (a->mailbox); - - if (t) { - i = 0; - for (u = *expn; u; u = u->next) { - if (m_strcmp(a->mailbox, u->data) == 0) { /* alias already found */ - debug_print(1, ("loop in alias found for '%s'\n", a->mailbox)); - i = 1; - break; - } - } + alias_t *list; - if (!i) { - u = p_new(LIST, 1); - u->data = m_strdup(a->mailbox); - u->next = *expn; - *expn = u; - w = rfc822_cpy_adr (t); - w = mutt_expand_aliases_r (w, expn); - if (head) - last->next = w; - else - head = last = w; - while (last && last->next) - last = last->next; - } - t = a; - a = a->next; - t->next = NULL; - rfc822_free_address (&t); - continue; - } - else { - struct passwd *pw = getpwnam (a->mailbox); + if (!a || !a->mailbox) + return NULL; - if (pw) { - char namebuf[STRING]; + for (list = Aliases; list; list = list->next) { + address_t *ap; - mutt_gecos_name (namebuf, sizeof (namebuf), pw); - str_replace (&a->personal, namebuf); + /* cycle through all addresses if this is a group alias */ + for (ap = list->addr; ap; ap = ap->next) { + if (!ap->group && ap->mailbox + && !ascii_strcasecmp(ap->mailbox, a->mailbox)) + return ap; } - } - } - - if (head) { - last->next = a; - last = last->next; } - else - head = last = a; - a = a->next; - last->next = NULL; - } - if (option (OPTUSEDOMAIN) && (fqdn = mutt_fqdn (1))) { - /* now qualify all local addresses */ - rfc822_qualify (head, fqdn); - } + return NULL; +} - return (head); +static int string_is_address(const char *str, const char *u, const char *d) +{ + char buf[LONG_STRING]; + snprintf(buf, sizeof (buf), "%s@%s", NONULL(u), NONULL(d)); + return !ascii_strcasecmp(str, buf); } -ADDRESS *mutt_expand_aliases (ADDRESS * a) +/* returns TRUE if the given address belongs to the user. */ +int mutt_addr_is_user(address_t *addr) { - ADDRESS *t; - LIST *expn = NULL; /* previously expanded aliases to avoid loops */ + /* NULL address is assumed to be the user. */ + if (!addr) + return 1; + + if (!addr->mailbox) + return 0; - t = mutt_expand_aliases_r (a, &expn); - mutt_free_list (&expn); - return (mutt_remove_duplicates (t)); + if (!ascii_strcasecmp(addr->mailbox, Username) + || string_is_address(addr->mailbox, Username, Hostname) + || string_is_address(addr->mailbox, Username, mutt_fqdn(0)) + || string_is_address(addr->mailbox, Username, mutt_fqdn(1)) + || (From && !ascii_strcasecmp(From->mailbox, addr->mailbox))) + { + return 1; + } + + return rx_list_match(Alternates, addr->mailbox) + && !rx_list_match(UnAlternates, addr->mailbox); } -void mutt_expand_aliases_env (ENVELOPE * env) +address_t *mutt_get_address(ENVELOPE *env, const char **pfxp) { - env->from = mutt_expand_aliases (env->from); - env->to = mutt_expand_aliases (env->to); - env->cc = mutt_expand_aliases (env->cc); - env->bcc = mutt_expand_aliases (env->bcc); - env->reply_to = mutt_expand_aliases (env->reply_to); - env->mail_followup_to = mutt_expand_aliases (env->mail_followup_to); +#define RETURN(s, adr) do { if (pfxp) *pfxp = s; return adr; } while (0) + + if (mutt_addr_is_user(env->from)) { + if (env->to && !mutt_is_mail_list(env->to)) { + RETURN("To", env->to); + } else { + RETURN("Cc", env->cc); + } + } else { + if (env->reply_to && !mutt_is_mail_list(env->reply_to)) { + RETURN("Reply-To", env->reply_to); + } else { + RETURN("From", env->from); + } + } + +#undef RETURN } +/* Only characters which are non-special to both the RFC 822 and the mutt + configuration parser are permitted. */ +static int alias_sanitize(const char *s, char *d) +{ + int rv = 0; + + while (*s) { + if (isalnum((unsigned char)(*s)) || strchr("-_+=.", *s)) { + if (d) + *d++ = *s; + } else { + if (!d) + return -1; + *d++ = '_'; + rv = -1; + } + s++; + } + + *d = '\0'; + return rv; +} /* * if someone has an address like @@ -165,229 +184,208 @@ void mutt_expand_aliases_env (ENVELOPE * env) * $ wants to be quoted since it may indicate the start of an environment * variable. */ - -static void write_safe_address (FILE * fp, char *s) +static void write_safe_address(FILE *fp, const char *s) { - while (*s) { - if (*s == '\\' || *s == '`' || *s == '\'' || *s == '"' || *s == '$') - fputc ('\\', fp); - fputc (*s, fp); - s++; - } + while (*s) { + if (strchr("\\`'\"$", *s)) { + fputc('\\', fp); + } + fputc(*s++, fp); + } + fputc('\n', fp); } -ADDRESS *mutt_get_address (ENVELOPE * env, const char **pfxp) +void mutt_create_alias(ENVELOPE *cur, address_t *iadr) { - ADDRESS *adr; - const char *pfx = NULL; + char buf[LONG_STRING], prompt[SHORT_STRING]; + address_t *adr = iadr; + alias_t *new; + FILE *rc; - if (mutt_addr_is_user (env->from)) { - if (env->to && !mutt_is_mail_list (env->to)) { - pfx = "To"; - adr = env->to; + if (cur) { + adr = mutt_get_address(cur, NULL); } - else { - pfx = "Cc"; - adr = env->cc; - } - } - else if (env->reply_to && !mutt_is_mail_list (env->reply_to)) { - pfx = "Reply-To"; - adr = env->reply_to; - } - else { - adr = env->from; - pfx = "From"; - } - - if (pfxp) - *pfxp = pfx; - return adr; -} + if (adr && adr->mailbox) { + const char *p = m_strchrnul(adr->mailbox, '@'); + m_strncpy(buf, sizeof(buf), adr->mailbox, p - adr->mailbox); + } else { + buf[0] = '\0'; + } -void mutt_create_alias (ENVELOPE * cur, ADDRESS * iadr) -{ - ALIAS *new, *t; - char buf[LONG_STRING], prompt[SHORT_STRING], *pc; - char *err = NULL; - char fixed[LONG_STRING]; - FILE *rc; - ADDRESS *adr = NULL; - - if (cur) { - adr = mutt_get_address (cur, NULL); - } - else if (iadr) { - adr = iadr; - } + /* Don't suggest a bad alias name in the event of a strange local part. */ + alias_sanitize(buf, buf); - if (adr && adr->mailbox) { - m_strcpy(buf, sizeof(buf), adr->mailbox); - if ((pc = strchr (buf, '@'))) - *pc = 0; - } - else - buf[0] = '\0'; + /* add a new alias */ + if (mutt_get_field(_("Alias as: "), buf, sizeof(buf), 0) || !buf[0]) + return; - /* Don't suggest a bad alias name in the event of a strange local part. */ - mutt_check_alias_name (buf, buf); + /* check to see if the user already has an alias defined */ + if (alias_lookup(buf)) { + mutt_error _("You already have an alias defined with that name!"); + return; + } -retry_name: - /* add a new alias */ - if (mutt_get_field (_("Alias as: "), buf, sizeof (buf), 0) != 0 || !buf[0]) - return; + alias_sanitize(buf, buf); + new = alias_new(); + new->name = m_strdup(buf); - /* check to see if the user already has an alias defined */ - if (mutt_lookup_alias (buf)) { - mutt_error _("You already have an alias defined with that name!"); + mutt_addrlist_to_local(adr); + if (adr) { + m_strcpy(buf, sizeof(buf), adr->mailbox); + } else { + buf[0] = 0; + } - return; - } + mutt_addrlist_to_idna(adr, NULL); - if (mutt_check_alias_name (buf, fixed)) { - switch (mutt_yesorno - (_("Warning: This alias name may not work. Fix it?"), M_YES)) { - case M_YES: - m_strcpy(buf, sizeof(buf), fixed); - goto retry_name; - case -1: - return; - } - } + do { + char *err = NULL; - new = p_new(ALIAS, 1); - new->self = new; - new->name = m_strdup(buf); + if (mutt_get_field(_("Address: "), buf, sizeof(buf), 0) || !buf[0]) { + alias_list_wipe(&new); + return; + } - mutt_addrlist_to_local (adr); + new->addr = rfc822_parse_adrlist(new->addr, buf); + if (!new->addr) + BEEP(); - if (adr) - m_strcpy(buf, sizeof(buf), adr->mailbox); - else - buf[0] = 0; + if (mutt_addrlist_to_idna(new->addr, &err)) { + mutt_error(_("Error: '%s' is a bad IDN."), err); + p_delete(&err); + mutt_sleep(1); + continue; + } + } while (!new->addr); - mutt_addrlist_to_idna (adr, NULL); + if (adr && adr->personal && !mutt_is_mail_list(adr)) { + m_strcpy(buf, sizeof(buf), adr->personal); + } else { + buf[0] = '\0'; + } - do { - if (mutt_get_field (_("Address: "), buf, sizeof (buf), 0) != 0 || !buf[0]) { - mutt_free_alias (&new); - return; + if (mutt_get_field(_("Personal name: "), buf, sizeof(buf), 0)) { + alias_list_wipe(&new); + return; } + new->addr->personal = m_strdup(buf); - if ((new->addr = rfc822_parse_adrlist (new->addr, buf)) == NULL) - BEEP (); - if (mutt_addrlist_to_idna (new->addr, &err)) { - mutt_error (_("Error: '%s' is a bad IDN."), err); - mutt_sleep (2); - continue; + buf[0] = '\0'; + rfc822_write_address(buf, sizeof(buf), new->addr, 1); + snprintf(prompt, sizeof(prompt), _("[%s = %s] Accept?"), new->name, buf); + if (mutt_yesorno(prompt, M_YES) != M_YES) { + alias_list_wipe(&new); + return; } - } - while (new->addr == NULL); - if (adr && adr->personal && !mutt_is_mail_list(adr)) - m_strcpy(buf, sizeof(buf), adr->personal); - else - buf[0] = 0; + alias_list_push(&Aliases, new); - if (mutt_get_field (_("Personal name: "), buf, sizeof (buf), 0) != 0) { - mutt_free_alias (&new); - return; - } - new->addr->personal = m_strdup(buf); + m_strcpy(buf, sizeof(buf), NONULL(AliasFile)); + if (mutt_get_field(_("Save to file: "), buf, sizeof(buf), M_FILE)) { + return; + } - buf[0] = 0; - rfc822_write_address (buf, sizeof (buf), new->addr, 1); - snprintf (prompt, sizeof (prompt), _("[%s = %s] Accept?"), new->name, buf); - if (mutt_yesorno (prompt, M_YES) != M_YES) { - mutt_free_alias (&new); - return; - } + mutt_expand_path(buf, sizeof (buf)); + rc = safe_fopen (buf, "a"); - if ((t = Aliases)) { - while (t->next) - t = t->next; - t->next = new; - } - else - Aliases = new; + if (rc) { + if (alias_sanitize(new->name, NULL)) { + mutt_quote_filename(buf, sizeof(buf), new->name); + fprintf(rc, "alias %s ", buf); + } else { + fprintf(rc, "alias %s ", new->name); + } - m_strcpy(buf, sizeof(buf), NONULL(AliasFile)); - if (mutt_get_field (_("Save to file: "), buf, sizeof (buf), M_FILE) != 0) - return; - mutt_expand_path (buf, sizeof (buf)); - if ((rc = safe_fopen (buf, "a"))) { - if (mutt_check_alias_name (new->name, NULL)) - mutt_quote_filename(buf, sizeof(buf), new->name); - else - m_strcpy(buf, sizeof(buf), new->name); - fprintf (rc, "alias %s ", buf); - buf[0] = 0; - rfc822_write_address (buf, sizeof (buf), new->addr, 0); - write_safe_address (rc, buf); - fputc ('\n', rc); - fclose (rc); - mutt_message _("Alias added."); - } - else - mutt_perror (buf); + buf[0] = '\0'; + rfc822_write_address(buf, sizeof(buf), new->addr, 0); + write_safe_address(rc, buf); + m_fclose(&rc); + mutt_message _("Alias added."); + } else { + mutt_perror(buf); + } } -/* - * Sanity-check an alias name: Only characters which are non-special to both - * the RFC 822 and the mutt configuration parser are permitted. - */ - -static int check_alias_name_char (char c) +static address_t *mutt_expand_aliases_r(address_t *a, string_list_t **expn) { - return (c == '-' || c == '_' || c == '+' || c == '=' || c == '.' || - isalnum ((unsigned char) c)); -} + address_t *pop, *head = NULL; + address_t **last = &head; + + while ((pop = address_list_pop(&a))) { + if (!pop->group && !pop->personal + && pop->mailbox && !strchr(pop->mailbox, '@')) + { + const address_t *t = alias_lookup(pop->mailbox); + + if (t) { + string_list_t *u; + + for (u = *expn; u; u = u->next) { + if (!m_strcmp(pop->mailbox, u->data)) { /* alias already found */ + address_list_wipe(&pop); + continue; + } + } + + /* save the fact we saw it */ + u = string_item_new(); + u->data = m_strdup(pop->mailbox); + u->next = *expn; + *expn = u; + address_list_wipe(&pop); + + /* recurse */ + last = address_list_last(last); + *last = mutt_expand_aliases_r(address_list_dup(t), expn); + continue; + } else { + struct passwd *pw = getpwnam(pop->mailbox); + + if (pw) { + char namebuf[STRING]; + mutt_gecos_name(namebuf, sizeof(namebuf), pw, GecosMask.rx); + m_strreplace(&pop->personal, namebuf); + } + } + } -int mutt_check_alias_name (const char *s, char *d) -{ - int rv = 0; + last = address_list_append(last, pop); + } - for (; *s; s++) { - if (!check_alias_name_char (*s)) { - if (!d) - return -1; - else { - *d++ = '_'; - rv = -1; - } + if (option(OPTUSEDOMAIN)) { + /* now qualify all local addresses */ + const char *fqdn = mutt_fqdn(1); + if (fqdn) + rfc822_qualify(head, fqdn); } - else if (d) - *d++ = *s; - } - if (d) - *d++ = *s; - return rv; + + return head; } -/* - * This routine looks to see if the user has an alias defined for the given - * address. - */ -ADDRESS *alias_reverse_lookup (ADDRESS * a) +address_t *mutt_expand_aliases(address_t *a) { - ALIAS *t = Aliases; - ADDRESS *ap; + address_t *t; + string_list_t *expn = NULL; /* previously expanded aliases to avoid loops */ - if (!a || !a->mailbox) - return NULL; + t = mutt_expand_aliases_r(a, &expn); + string_list_wipe(&expn); + address_list_uniq(t); + return t; +} - for (; t; t = t->next) { - /* cycle through all addresses if this is a group alias */ - for (ap = t->addr; ap; ap = ap->next) { - if (!ap->group && ap->mailbox && - ascii_strcasecmp (ap->mailbox, a->mailbox) == 0) - return ap; - } - } - return 0; +void mutt_expand_aliases_env(ENVELOPE *env) +{ + env->from = mutt_expand_aliases(env->from); + env->to = mutt_expand_aliases(env->to); + env->cc = mutt_expand_aliases(env->cc); + env->bcc = mutt_expand_aliases(env->bcc); + env->reply_to = mutt_expand_aliases(env->reply_to); + env->mail_followup_to = mutt_expand_aliases(env->mail_followup_to); } +/************* READ MARK *********************/ + /* alias_complete() -- alias completion routine * * given a partial alias, this routine attempts to fill in the alias @@ -396,20 +394,20 @@ ADDRESS *alias_reverse_lookup (ADDRESS * a) */ int mutt_alias_complete (char *s, size_t buflen) { - ALIAS *a = Aliases; - ALIAS *a_list = NULL, *a_cur = NULL; + alias_t *a = Aliases; + alias_t *a_list = NULL, *a_cur = NULL; char bestname[HUGE_STRING]; int i; #define min(a,b) ((aname && strstr (a->name, s) == a->name) { if (!bestname[0]) /* init */ - m_strcpy(bestname, MIN(m_strlen(a->name) + 1, sizeof(bestname)), + m_strcpy(bestname, MIN(m_strlen(a->name) + 1, ssizeof(bestname)), a->name); else { for (i = 0; a->name[i] && a->name[i] == bestname[i]; i++); @@ -432,12 +430,12 @@ int mutt_alias_complete (char *s, size_t buflen) while (a) { if (a->name && (strstr (a->name, s) == a->name)) { if (!a_list) /* init */ - a_cur = a_list = p_new(ALIAS, 1); + a_cur = a_list = alias_new(); else { - a_cur->next = p_new(ALIAS, 1); + a_cur->next = alias_new(); a_cur = a_cur->next; } - memcpy (a_cur, a, sizeof (ALIAS)); + *a_cur = *a; a_cur->next = NULL; } a = a->next; @@ -467,7 +465,7 @@ int mutt_alias_complete (char *s, size_t buflen) Aliases = a_cur->next; a_cur->next = NULL; - mutt_free_alias (&a_cur); + alias_list_wipe(&a_cur); if (a_list) a_cur = a_list; @@ -483,110 +481,50 @@ int mutt_alias_complete (char *s, size_t buflen) return 0; } -static int string_is_address (const char *str, const char *u, const char *d) -{ - char buf[LONG_STRING]; - - snprintf (buf, sizeof (buf), "%s@%s", NONULL (u), NONULL (d)); - if (ascii_strcasecmp (str, buf) == 0) - return 1; - - return 0; -} - -/* returns TRUE if the given address belongs to the user. */ -int mutt_addr_is_user (ADDRESS * addr) -{ - /* NULL address is assumed to be the user. */ - if (!addr) { - debug_print(5, ("yes, NULL address\n")); - return 1; - } - if (!addr->mailbox) { - debug_print(5, ("no, no mailbox\n")); - return 0; - } - - if (ascii_strcasecmp (addr->mailbox, Username) == 0) { - debug_print(5, ("yes, %s = %s\n", addr->mailbox, Username)); - return 1; - } - if (string_is_address (addr->mailbox, Username, Hostname)) { - debug_print(5, ("yes, %s = %s @ %s \n", addr->mailbox, Username, Hostname)); - return 1; - } - if (string_is_address (addr->mailbox, Username, mutt_fqdn (0))) { - debug_print(5, ("yes, %s = %s @ %s \n", addr->mailbox, Username, mutt_fqdn (0))); - return 1; - } - if (string_is_address (addr->mailbox, Username, mutt_fqdn (1))) { - debug_print(5, ("yes, %s = %s @ %s \n", addr->mailbox, Username, mutt_fqdn (1))); - return 1; - } - - if (From && !ascii_strcasecmp (From->mailbox, addr->mailbox)) { - debug_print(5, ("yes, %s = %s\n", addr->mailbox, From->mailbox)); - return 1; - } - - if (rx_list_match (Alternates, addr->mailbox)) { - debug_print(5, ("yes, %s matched by alternates.\n", addr->mailbox)); - if (rx_list_match (UnAlternates, addr->mailbox)) - debug_print(5, ("but, %s matched by unalternates.\n", addr->mailbox)); - else - return 1; - } - - debug_print(5, ("no, all failed.\n")); - return 0; -} - -static const char *alias_format_str (char *dest, size_t destlen, char op, - const char *src, const char *fmt, - const char *ifstring, - const char *elsestring, - unsigned long data, format_flag flags) +static const format_t *alias_format_str (char *dest, size_t destlen, char op, + const format_t *src, const char *fmt, + const char *ifstring __attribute__ ((unused)), + const char *elsestring __attribute__ ((unused)), + unsigned long data, format_flag flags __attribute__ ((unused))) { char tmp[SHORT_STRING], adr[SHORT_STRING]; - ALIAS *alias = (ALIAS *) data; + alias_t *alias = (alias_t *) data; switch (op) { case 'f': - snprintf (tmp, sizeof (tmp), "%%%ss", fmt); - snprintf (dest, destlen, tmp, alias->del ? "D" : " "); + m_strcpy(dest, destlen, alias->del ? "D" : " "); break; case 'a': - mutt_format_s (dest, destlen, fmt, alias->name); + mutt_format_s(dest, destlen, fmt, alias->name); break; case 'r': - adr[0] = 0; - rfc822_write_address (adr, sizeof (adr), alias->addr, 1); - snprintf (tmp, sizeof (tmp), "%%%ss", fmt); - snprintf (dest, destlen, tmp, adr); + adr[0] = '\0'; + rfc822_write_address(adr, sizeof(adr), alias->addr, 1); + snprintf(tmp, sizeof(tmp), "%%%ss", fmt); + snprintf(dest, destlen, tmp, adr); break; case 'n': - snprintf (tmp, sizeof (tmp), "%%%sd", fmt); - snprintf (dest, destlen, tmp, alias->num + 1); + snprintf(tmp, sizeof(tmp), "%%%sd", fmt); + snprintf(dest, destlen, tmp, alias->num + 1); break; case 't': - dest[0] = alias->tagged ? '*' : ' '; - dest[1] = 0; + m_strcpy(dest, destlen, alias->tagged ? "*" : " "); break; } return (src); } -static void alias_entry (char *s, size_t slen, MUTTMENU * m, int num) +static void alias_entry (char *s, ssize_t slen, MUTTMENU * m, int num) { - mutt_FormatString (s, slen, NONULL (AliasFmt), alias_format_str, - (unsigned long) ((ALIAS **) m->data)[num], + mutt_FormatString (s, slen, NONULL (AliasFmt), (format_t *)alias_format_str, + (unsigned long)((alias_t **)m->data)[num], M_FORMAT_ARROWCURSOR); } static int alias_tag (MUTTMENU * menu, int n, int m) { - ALIAS *cur = ((ALIAS **) menu->data)[n]; + alias_t *cur = ((alias_t **) menu->data)[n]; int ot = cur->tagged; cur->tagged = (m >= 0 ? m : !cur->tagged); @@ -596,8 +534,8 @@ static int alias_tag (MUTTMENU * menu, int n, int m) static int alias_SortAlias (const void *a, const void *b) { - ALIAS *pa = *(ALIAS **) a; - ALIAS *pb = *(ALIAS **) b; + alias_t *pa = *(alias_t **) a; + alias_t *pb = *(alias_t **) b; int r = m_strcasecmp(pa->name, pb->name); return (RSORT (r)); @@ -605,8 +543,8 @@ static int alias_SortAlias (const void *a, const void *b) static int alias_SortAddress (const void *a, const void *b) { - ADDRESS *pa = (*(ALIAS **) a)->addr; - ADDRESS *pb = (*(ALIAS **) b)->addr; + address_t *pa = (*(alias_t **) a)->addr; + address_t *pb = (*(alias_t **) b)->addr; int r; if (pa == pb) @@ -628,11 +566,11 @@ static int alias_SortAddress (const void *a, const void *b) return (RSORT (r)); } -void mutt_alias_menu (char *buf, size_t buflen, ALIAS * aliases) +void mutt_alias_menu (char *buf, size_t buflen, alias_t * aliases) { - ALIAS *aliasp; + alias_t *aliasp; MUTTMENU *menu; - ALIAS **AliasTable = NULL; + alias_t **AliasTable = NULL; int t = -1; int i, done = 0; int op; @@ -654,8 +592,8 @@ void mutt_alias_menu (char *buf, size_t buflen, ALIAS * aliases) menu->tag = alias_tag; menu->menu = MENU_ALIAS; menu->title = _("Aliases"); - menu->help = - mutt_compile_help (helpstr, sizeof (helpstr), MENU_ALIAS, AliasHelp); + menu->help = mutt_compile_help(helpstr, sizeof(helpstr), + MENU_ALIAS, AliasHelp); new_aliases: @@ -663,8 +601,8 @@ new_aliases: /* count the number of aliases */ for (aliasp = aliases; aliasp; aliasp = aliasp->next) { - aliasp->self->del = 0; - aliasp->self->tagged = 0; + aliasp->del = 0; + aliasp->tagged = 0; menu->max++; } @@ -672,12 +610,12 @@ new_aliases: menu->data = AliasTable; for (i = omax, aliasp = aliases; aliasp; aliasp = aliasp->next, i++) { - AliasTable[i] = aliasp->self; + AliasTable[i] = aliasp; aliases = aliasp; } if ((SortAlias & SORT_MASK) != SORT_ORDER) { - qsort (AliasTable, i, sizeof (ALIAS *), + qsort (AliasTable, i, sizeof (alias_t *), (SortAlias & SORT_MASK) == SORT_ADDRESS ? alias_SortAddress : alias_SortAlias); } @@ -702,7 +640,7 @@ new_aliases: menu->redraw |= REDRAW_INDEX; } else { - AliasTable[menu->current]->self->del = (op == OP_DELETE) ? 1 : 0; + AliasTable[menu->current]->del = (op == OP_DELETE) ? 1 : 0; menu->redraw |= REDRAW_CURRENT; if (option (OPTRESOLVE) && menu->current < menu->max - 1) { menu->current++; @@ -733,5 +671,4 @@ new_aliases: mutt_menuDestroy (&menu); p_delete(&AliasTable); - }