X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=alias.c;h=68afc256a0c64e24632a477113dbef4a91f6a6be;hp=508e24b6eb3d8b650589d7e6deac65d5d12b007a;hb=f3cbb9f51357972f6e74244494236a41dc4d84cd;hpb=6833ce8bdca2d64e14485118f2a4417b7e1cb1b1 diff --git a/alias.c b/alias.c index 508e24b..68afc25 100644 --- a/alias.c +++ b/alias.c @@ -1,144 +1,168 @@ /* + * 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 - * - * 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., 59 Temple Place - Suite 330, Boston, MA 02111, USA. - */ - -#include "mutt.h" -#include "mutt_regex.h" -#include "mutt_curses.h" + * + * This file is part of mutt-ng, see http://www.muttng.org/. + * It's licensed under the GNU General Public License, + * please see the file GPL in the top level source directory. + */ + +#include + +#include + +#include +#include +#include + +#include "alias.h" #include "mutt_idna.h" +#include "sort.h" + +char *AliasFmt; +char *AliasFile; +alias_t *Aliases; +rx_t GecosMask; -#include -#include +#define RSORT(x) (SortAlias & SORT_REVERSE) ? -x : x -ADDRESS *mutt_lookup_alias (const char *s) +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} +}; + +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 (!mutt_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 (mutt_strcmp (a->mailbox, u->data) == 0) /* alias already found */ - { - dprint (1, (debugfile, "mutt_expand_aliases_r(): loop in alias found for '%s'\n", a->mailbox)); - i = 1; - break; - } - } - - if (!i) - { - u = safe_malloc (sizeof (LIST)); - u->data = safe_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; + alias_t *list; + + if (!a || !a->mailbox) + return NULL; + + for (list = Aliases; list; list = list->next) { + address_t *ap; + + /* 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; } - t = a; - a = a->next; - t->next = NULL; - rfc822_free_address (&t); - continue; - } - else - { - struct passwd *pw = getpwnam (a->mailbox); - - if (pw) - { - char namebuf[STRING]; - - mutt_gecos_name (namebuf, sizeof (namebuf), pw); - mutt_str_replace (&a->personal, namebuf); - -#ifdef EXACT_ADDRESS - FREE (&a->val); -#endif - } - } } - if (head) + return NULL; +} + +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); +} + +/* returns TRUE if the given address belongs to the user. */ +int mutt_addr_is_user(address_t *addr) +{ + /* NULL address is assumed to be the user. */ + if (!addr) + return 1; + + if (!addr->mailbox) + return 0; + + 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))) { - last->next = a; - last = last->next; + return 1; } - 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 (head); + return rx_list_match(Alternates, addr->mailbox) + && !rx_list_match(UnAlternates, addr->mailbox); } -ADDRESS *mutt_expand_aliases (ADDRESS *a) +address_t *mutt_get_address(ENVELOPE *env, const char **pfxp) { - ADDRESS *t; - LIST *expn = NULL; /* previously expanded aliases to avoid loops */ +#define RETURN(s, adr) do { if (pfxp) *pfxp = s; return adr; } while (0) - t = mutt_expand_aliases_r (a, &expn); - mutt_free_list (&expn); - return (mutt_remove_duplicates (t)); + 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 } -void mutt_expand_aliases_env (ENVELOPE *env) +/* 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) { - 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); -} + 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 @@ -160,250 +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, char **pfxp) +void mutt_create_alias(ENVELOPE *cur, address_t *iadr) { - ADDRESS *adr; - 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; + + 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'; } - } - 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; + /* Don't suggest a bad alias name in the event of a strange local part. */ + alias_sanitize(buf, buf); - return adr; -} + /* add a new alias */ + if (mutt_get_field(_("Alias as: "), buf, sizeof(buf), 0) || !buf[0]) + return; -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; - } + /* 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; + } - if (adr && adr->mailbox) - { - strfcpy (buf, adr->mailbox, sizeof (buf)); - if ((pc = strchr (buf, '@'))) - *pc = 0; - } - else - buf[0] = '\0'; + alias_sanitize(buf, buf); + new = alias_new(); + new->name = m_strdup(buf); - /* Don't suggest a bad alias name in the event of a strange local part. */ - mutt_check_alias_name (buf, buf); - -retry_name: - /* add a new alias */ - if (mutt_get_field (_("Alias as: "), buf, sizeof (buf), 0) != 0 || !buf[0]) - return; + mutt_addrlist_to_local(adr); + if (adr) { + m_strcpy(buf, sizeof(buf), adr->mailbox); + } else { + buf[0] = 0; + } - /* 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!"); - return; - } - - if (mutt_check_alias_name (buf, fixed)) - { - switch (mutt_yesorno (_("Warning: This alias name may not work. Fix it?"), M_YES)) - { - case M_YES: - strfcpy (buf, fixed, sizeof (buf)); - goto retry_name; - case -1: - return; + mutt_addrlist_to_idna(adr, NULL); + + do { + char *err = NULL; + + if (mutt_get_field(_("Address: "), buf, sizeof(buf), 0) || !buf[0]) { + alias_list_wipe(&new); + return; + } + + new->addr = rfc822_parse_adrlist(new->addr, buf); + if (!new->addr) + BEEP(); + + 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); + + if (adr && adr->personal && !mutt_is_mail_list(adr)) { + m_strcpy(buf, sizeof(buf), adr->personal); + } else { + buf[0] = '\0'; } - } - - new = safe_calloc (1, sizeof (ALIAS)); - new->self = new; - new->name = safe_strdup (buf); - - mutt_addrlist_to_local (adr); - - if (adr) - strfcpy (buf, adr->mailbox, sizeof (buf)); - else - buf[0] = 0; - mutt_addrlist_to_idna (adr, NULL); - - 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; } - - 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; + new->addr->personal = m_strdup(buf); + + 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)) - strfcpy (buf, adr->personal, sizeof (buf)); - else - buf[0] = 0; - if (mutt_get_field (_("Personal name: "), buf, sizeof (buf), 0) != 0) - { - mutt_free_alias (&new); - return; - } - new->addr->personal = safe_strdup (buf); - - 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; - } + alias_list_push(&Aliases, new); - if ((t = Aliases)) - { - while (t->next) - t = t->next; - t->next = new; - } - else - Aliases = new; + m_strcpy(buf, sizeof(buf), NONULL(AliasFile)); + if (mutt_get_field(_("Save to file: "), buf, sizeof(buf), M_FILE)) { + return; + } - strfcpy (buf, NONULL (AliasFile), sizeof (buf)); - if (mutt_get_field (_("Save to file: "), buf, sizeof (buf), M_FILE) != 0) - return; - mutt_expand_path (buf, sizeof (buf)); - if ((rc = fopen (buf, "a"))) - { - if (mutt_check_alias_name (new->name, NULL)) - mutt_quote_filename (buf, sizeof (buf), new->name); - else - strfcpy (buf, new->name, sizeof (buf)); - 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); -} + mutt_expand_path(buf, sizeof (buf)); + rc = safe_fopen (buf, "a"); -/* - * Sanity-check an alias name: Only characters which are non-special to both - * the RFC 822 and the mutt configuration parser are permitted. - */ + 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); + } -static int check_alias_name_char (char c) -{ - return (c == '-' || c == '_' || c == '+' || c == '=' || c == '.' || - isalnum ((unsigned char) c)); + 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); + } } -int mutt_check_alias_name (const char *s, char *d) +static address_t *mutt_expand_aliases_r(address_t *a, string_list_t **expn) { - int rv = 0; - for (; *s; s++) - { - if (!check_alias_name_char (*s)) - { - if (!d) - return -1; - else - { - *d++ = '_'; - rv = -1; - } + 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); + } + } + } + + last = address_list_append(last, pop); } - else if (d) - *d++ = *s; - } - if (d) - *d++ = *s; - return rv; + + if (option(OPTUSEDOMAIN)) { + /* now qualify all local addresses */ + const char *fqdn = mutt_fqdn(1); + if (fqdn) + rfc822_qualify(head, fqdn); + } + + 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 @@ -412,166 +394,281 @@ 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 */ - strfcpy (bestname, a->name, - min (mutt_strlen (a->name) + 1, sizeof (bestname))); - else - { - for (i = 0 ; a->name[i] && a->name[i] == bestname[i] ; i++) - ; - bestname[i] = 0; - } + if (s[0] != 0) { /* avoid empty string as strstr argument */ + p_clear(bestname, countof(bestname)); + + while (a) { + if (a->name && strstr (a->name, s) == a->name) { + if (!bestname[0]) /* init */ + 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++); + bestname[i] = 0; + } } a = a->next; } - if (bestname[0] != 0) - { - if (mutt_strcmp (bestname, s) != 0) - { - /* we are adding something to the completion */ - strfcpy (s, bestname, mutt_strlen (bestname) + 1); - return 1; + if (bestname[0] != 0) { + if (m_strcmp(bestname, s) != 0) { + /* we are adding something to the completion */ + m_strcpy(s, m_strlen(bestname) + 1, bestname); + return 1; } /* build alias list and show it */ a = Aliases; - while (a) - { - if (a->name && (strstr (a->name, s) == a->name)) - { - if (!a_list) /* init */ - a_cur = a_list = (ALIAS *) safe_malloc (sizeof (ALIAS)); - else - { - a_cur->next = (ALIAS *) safe_malloc (sizeof (ALIAS)); - a_cur = a_cur->next; - } - memcpy (a_cur, a, sizeof (ALIAS)); - a_cur->next = NULL; - } - a = a->next; + while (a) { + if (a->name && (strstr (a->name, s) == a->name)) { + if (!a_list) /* init */ + a_cur = a_list = alias_new(); + else { + a_cur->next = alias_new(); + a_cur = a_cur->next; + } + *a_cur = *a; + a_cur->next = NULL; + } + a = a->next; } } } bestname[0] = 0; - mutt_alias_menu (bestname, sizeof(bestname), a_list ? a_list : Aliases); + mutt_alias_menu (bestname, sizeof (bestname), a_list ? a_list : Aliases); if (bestname[0] != 0) - strfcpy (s, bestname, buflen); + m_strcpy(s, buflen, bestname); /* free the alias list */ - while (a_list) - { + while (a_list) { a_cur = a_list; a_list = a_list->next; - FREE (&a_cur); + p_delete(&a_cur); } /* remove any aliases marked for deletion */ a_list = NULL; - for (a_cur = Aliases; a_cur;) - { - if (a_cur->del) - { + for (a_cur = Aliases; a_cur;) { + if (a_cur->del) { if (a_list) - a_list->next = a_cur->next; + a_list->next = a_cur->next; else - Aliases = a_cur->next; - + 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; + a_cur = a_list; else - a_cur = Aliases; + a_cur = Aliases; } - else - { + else { a_list = a_cur; - a_cur = a_cur->next; + a_cur = a_cur->next; } } - + return 0; } -static int string_is_address(const char *str, const char *u, const char *d) +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 buf[LONG_STRING]; - - snprintf(buf, sizeof(buf), "%s@%s", NONULL(u), NONULL(d)); - if (ascii_strcasecmp(str, buf) == 0) - return 1; - - return 0; + char tmp[SHORT_STRING], adr[SHORT_STRING]; + alias_t *alias = (alias_t *) data; + + switch (op) { + case 'f': + m_strcpy(dest, destlen, alias->del ? "D" : " "); + break; + case 'a': + 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); + break; + case 'n': + snprintf(tmp, sizeof(tmp), "%%%sd", fmt); + snprintf(dest, destlen, tmp, alias->num + 1); + break; + case 't': + m_strcpy(dest, destlen, alias->tagged ? "*" : " "); + break; + } + + return (src); } -/* returns TRUE if the given address belongs to the user. */ -int mutt_addr_is_user (ADDRESS *addr) +static void alias_entry (char *s, ssize_t slen, MUTTMENU * m, int 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_t *cur = ((alias_t **) menu->data)[n]; + int ot = cur->tagged; + + cur->tagged = (m >= 0 ? m : !cur->tagged); + + return cur->tagged - ot; +} + +static int alias_SortAlias (const void *a, const void *b) +{ + alias_t *pa = *(alias_t **) a; + alias_t *pb = *(alias_t **) b; + int r = m_strcasecmp(pa->name, pb->name); + + return (RSORT (r)); +} + +static int alias_SortAddress (const void *a, const void *b) { - /* NULL address is assumed to be the user. */ - if (!addr) - { - dprint (5, (debugfile, "mail_addr_is_user: yes, NULL address\n")); - return 1; + address_t *pa = (*(alias_t **) a)->addr; + address_t *pb = (*(alias_t **) b)->addr; + int r; + + if (pa == pb) + r = 0; + else if (pa == NULL) + r = -1; + else if (pb == NULL) + r = 1; + else if (pa->personal) { + if (pb->personal) + r = m_strcasecmp(pa->personal, pb->personal); + else + r = 1; } - if (!addr->mailbox) - { - dprint (5, (debugfile, "mail_addr_is_user: no, no mailbox\n")); - return 0; + else if (pb->personal) + r = -1; + else + r = ascii_strcasecmp (pa->mailbox, pb->mailbox); + return (RSORT (r)); +} + +void mutt_alias_menu (char *buf, size_t buflen, alias_t * aliases) +{ + alias_t *aliasp; + MUTTMENU *menu; + alias_t **AliasTable = NULL; + int t = -1; + int i, done = 0; + int op; + char helpstr[SHORT_STRING]; + + int omax; + + if (!aliases) { + mutt_error _("You have no aliases!"); + + return; } - if (ascii_strcasecmp (addr->mailbox, Username) == 0) - { - dprint (5, (debugfile, "mail_addr_is_user: yes, %s = %s\n", addr->mailbox, Username)); - return 1; + /* tell whoever called me to redraw the screen when I return */ + set_option (OPTNEEDREDRAW); + + menu = mutt_new_menu (); + menu->make_entry = alias_entry; + menu->tag = alias_tag; + menu->menu = MENU_ALIAS; + menu->title = _("Aliases"); + menu->help = mutt_compile_help(helpstr, sizeof(helpstr), + MENU_ALIAS, AliasHelp); + +new_aliases: + + omax = menu->max; + + /* count the number of aliases */ + for (aliasp = aliases; aliasp; aliasp = aliasp->next) { + aliasp->del = 0; + aliasp->tagged = 0; + menu->max++; } - if (string_is_address(addr->mailbox, Username, Hostname)) - { - dprint (5, (debugfile, "mail_addr_is_user: yes, %s = %s @ %s \n", addr->mailbox, Username, Hostname)); - return 1; + + p_realloc(&AliasTable, menu->max); + menu->data = AliasTable; + + for (i = omax, aliasp = aliases; aliasp; aliasp = aliasp->next, i++) { + AliasTable[i] = aliasp; + aliases = aliasp; } - if (string_is_address(addr->mailbox, Username, mutt_fqdn(0))) - { - dprint (5, (debugfile, "mail_addr_is_user: yes, %s = %s @ %s \n", addr->mailbox, Username, mutt_fqdn (0))); - return 1; + + if ((SortAlias & SORT_MASK) != SORT_ORDER) { + qsort (AliasTable, i, sizeof (alias_t *), + (SortAlias & SORT_MASK) == + SORT_ADDRESS ? alias_SortAddress : alias_SortAlias); } - if (string_is_address(addr->mailbox, Username, mutt_fqdn(1))) - { - dprint (5, (debugfile, "mail_addr_is_user: yes, %s = %s @ %s \n", addr->mailbox, Username, mutt_fqdn (1))); - return 1; + + for (i = 0; i < menu->max; i++) + AliasTable[i]->num = i; + + while (!done) { + if (aliases->next) { + menu->redraw |= REDRAW_FULL; + aliases = aliases->next; + goto new_aliases; + } + + switch ((op = mutt_menuLoop (menu))) { + case OP_DELETE: + case OP_UNDELETE: + if (menu->tagprefix) { + for (i = 0; i < menu->max; i++) + if (AliasTable[i]->tagged) + AliasTable[i]->del = (op == OP_DELETE) ? 1 : 0; + menu->redraw |= REDRAW_INDEX; + } + else { + AliasTable[menu->current]->del = (op == OP_DELETE) ? 1 : 0; + menu->redraw |= REDRAW_CURRENT; + if (option (OPTRESOLVE) && menu->current < menu->max - 1) { + menu->current++; + menu->redraw |= REDRAW_INDEX; + } + } + break; + case OP_GENERIC_SELECT_ENTRY: + t = menu->current; + case OP_EXIT: + done = 1; + break; + } } - if (From && !ascii_strcasecmp (From->mailbox, addr->mailbox)) - { - dprint (5, (debugfile, "mail_addr_is_user: yes, %s = %s\n", addr->mailbox, From->mailbox)); - return 1; + for (i = 0; i < menu->max; i++) { + if (AliasTable[i]->tagged) { + mutt_addrlist_to_local (AliasTable[i]->addr); + rfc822_write_address (buf, buflen, AliasTable[i]->addr, 0); + t = -1; + } } - if (mutt_match_rx_list (addr->mailbox, Alternates)) - { - dprint (5, (debugfile, "mail_addr_is_user: yes, %s matched by alternates.\n", addr->mailbox)); - return 1; + if (t != -1) { + mutt_addrlist_to_local (AliasTable[t]->addr); + rfc822_write_address (buf, buflen, AliasTable[t]->addr, 0); } - - dprint (5, (debugfile, "mail_addr_is_user: no, all failed.\n")); - return 0; + + mutt_menuDestroy (&menu); + p_delete(&AliasTable); }