From: Pierre Habouzit Date: Sun, 12 Nov 2006 23:23:46 +0000 (+0100) Subject: begin to work on alias.[hc] X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=commitdiff_plain;h=723f7ae3f24f7881c9ce87abf933cd5bec4ac0bc begin to work on alias.[hc] ALIAS -> alias_t. make some functions better. Signed-off-by: Pierre Habouzit --- diff --git a/alias.c b/alias.c index fa83c6f..add8028 100644 --- a/alias.c +++ b/alias.c @@ -36,24 +36,199 @@ #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_t *mutt_lookup_alias (const char *s) +void alias_wipe(alias_t *a) { + p_delete(&a->name); + address_delete(&a->addr); + alias_delete(&a->next); +} + +address_t *alias_lookup(alias_t *list, const char *s) +{ + while (list) { + if (!m_strcasecmp(s, list->name)) + return list->addr; + list = list->next; + } + + return NULL; +} + +/* 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) { - ALIAS *t = Aliases; + 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++; + } - for (; t; t = t->next) - if (!m_strcasecmp(s, t->name)) - return (t->addr); - return (NULL); /* no such alias */ + *d = '\0'; + return rv; +} + +/* + * if someone has an address like + * From: Michael `/bin/rm -f ~` Elkins + * and the user creates an alias for this, Mutt could wind up executing + * the backtics because it writes aliases like + * alias me Michael `/bin/rm -f ~` Elkins + * To avoid this problem, use a backslash (\) to quote any backtics. We also + * need to quote backslashes as well, since you could defeat the above by + * doing + * From: Michael \`/bin/rm -f ~\` Elkins + * since that would get aliased as + * alias me Michael \\`/bin/rm -f ~\\` Elkins + * which still gets evaluated because the double backslash is not a quote. + * + * Additionally, we need to quote ' and " characters - otherwise, mutt will + * interpret them on the wrong parsing step. + * + * $ wants to be quoted since it may indicate the start of an environment + * variable. + */ +static void write_safe_address(FILE *fp, const char *s) +{ + while (*s) { + if (strchr("\\`'\"$", *s)) { + fputc('\\', fp); + } + fputc(*s++, fp); + } + fputc('\n', fp); } +void mutt_create_alias(ENVELOPE *cur, address_t *iadr) +{ + char buf[LONG_STRING], prompt[SHORT_STRING]; + address_t *adr = iadr; + alias_t *new; + FILE *rc; + + if (cur) { + adr = mutt_get_address(cur, NULL); + } + + 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'; + } + + /* Don't suggest a bad alias name in the event of a strange local part. */ + alias_sanitize(buf, buf); + + /* add a new alias */ + if (mutt_get_field(_("Alias as: "), buf, sizeof(buf), 0) || !buf[0]) + return; + + /* check to see if the user already has an alias defined */ + if (alias_lookup(Aliases, buf)) { + mutt_error _("You already have an alias defined with that name!"); + return; + } + + alias_sanitize(buf, buf); + new = alias_new(); + new->name = m_strdup(buf); + + mutt_addrlist_to_local(adr); + if (adr) { + m_strcpy(buf, sizeof(buf), adr->mailbox); + } else { + buf[0] = 0; + } + + mutt_addrlist_to_idna(adr, NULL); + + do { + const char *err = NULL; + + if (mutt_get_field(_("Address: "), buf, sizeof(buf), 0) || !buf[0]) { + alias_delete(&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); + 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'; + } + + if (mutt_get_field(_("Personal name: "), buf, sizeof(buf), 0)) { + alias_delete(&new); + return; + } + 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_delete(&new); + return; + } + + alias_list_push(&Aliases, new); + + m_strcpy(buf, sizeof(buf), NONULL(AliasFile)); + if (mutt_get_field(_("Save to file: "), buf, sizeof(buf), M_FILE)) { + return; + } + + mutt_expand_path(buf, sizeof (buf)); + rc = safe_fopen (buf, "a"); + + 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); + } + + buf[0] = '\0'; + rfc822_write_address(buf, sizeof(buf), new->addr, 0); + write_safe_address(rc, buf); + fclose(rc); + mutt_message _("Alias added."); + } else { + mutt_perror(buf); + } +} + +/************* READ MARK *********************/ + + static address_t *mutt_expand_aliases_r (address_t * a, LIST ** expn) { address_t *head = NULL, *last = NULL, *t, *w; @@ -64,7 +239,7 @@ static address_t *mutt_expand_aliases_r (address_t * a, LIST ** expn) while (a) { if (!a->group && !a->personal && a->mailbox && strchr (a->mailbox, '@') == NULL) { - t = mutt_lookup_alias (a->mailbox); + t = alias_lookup(Aliases, a->mailbox); if (t) { i = 0; @@ -147,37 +322,6 @@ void mutt_expand_aliases_env (ENVELOPE * env) } -/* - * if someone has an address like - * From: Michael `/bin/rm -f ~` Elkins - * and the user creates an alias for this, Mutt could wind up executing - * the backtics because it writes aliases like - * alias me Michael `/bin/rm -f ~` Elkins - * To avoid this problem, use a backslash (\) to quote any backtics. We also - * need to quote backslashes as well, since you could defeat the above by - * doing - * From: Michael \`/bin/rm -f ~\` Elkins - * since that would get aliased as - * alias me Michael \\`/bin/rm -f ~\\` Elkins - * which still gets evaluated because the double backslash is not a quote. - * - * Additionally, we need to quote ' and " characters - otherwise, mutt will - * interpret them on the wrong parsing step. - * - * $ wants to be quoted since it may indicate the start of an environment - * variable. - */ - -static void write_safe_address (FILE * fp, char *s) -{ - while (*s) { - if (*s == '\\' || *s == '`' || *s == '\'' || *s == '"' || *s == '$') - fputc ('\\', fp); - fputc (*s, fp); - s++; - } -} - address_t *mutt_get_address (ENVELOPE * env, const char **pfxp) { address_t *adr; @@ -208,172 +352,13 @@ address_t *mutt_get_address (ENVELOPE * env, const char **pfxp) return adr; } -void mutt_create_alias (ENVELOPE * cur, address_t * iadr) -{ - ALIAS *new, *t; - char buf[LONG_STRING], prompt[SHORT_STRING], *pc; - char *err = NULL; - char fixed[LONG_STRING]; - FILE *rc; - address_t *adr = NULL; - - if (cur) { - adr = mutt_get_address (cur, NULL); - } - else if (iadr) { - adr = iadr; - } - - if (adr && adr->mailbox) { - m_strcpy(buf, sizeof(buf), adr->mailbox); - if ((pc = strchr (buf, '@'))) - *pc = 0; - } - else - buf[0] = '\0'; - - /* 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; - - /* 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: - m_strcpy(buf, sizeof(buf), fixed); - goto retry_name; - case -1: - return; - } - } - - new = p_new(ALIAS, 1); - new->self = new; - new->name = m_strdup(buf); - - mutt_addrlist_to_local (adr); - - if (adr) - m_strcpy(buf, sizeof(buf), adr->mailbox); - 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 ((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; - } - } - while (new->addr == NULL); - - if (adr && adr->personal && !mutt_is_mail_list(adr)) - m_strcpy(buf, sizeof(buf), adr->personal); - else - buf[0] = 0; - - if (mutt_get_field (_("Personal name: "), buf, sizeof (buf), 0) != 0) { - mutt_free_alias (&new); - return; - } - 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) { - mutt_free_alias (&new); - return; - } - - 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) != 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); -} - -/* - * 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) -{ - return (c == '-' || c == '_' || c == '+' || c == '=' || c == '.' || - isalnum ((unsigned char) c)); -} - -int mutt_check_alias_name (const char *s, char *d) -{ - int rv = 0; - - for (; *s; s++) { - if (!check_alias_name_char (*s)) { - if (!d) - return -1; - else { - *d++ = '_'; - rv = -1; - } - } - else if (d) - *d++ = *s; - } - if (d) - *d++ = *s; - return rv; -} - /* * This routine looks to see if the user has an alias defined for the given * address. */ address_t *alias_reverse_lookup (address_t * a) { - ALIAS *t = Aliases; + alias_t *t = Aliases; address_t *ap; if (!a || !a->mailbox) @@ -398,8 +383,8 @@ address_t *alias_reverse_lookup (address_t * 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; @@ -434,12 +419,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; @@ -469,7 +454,7 @@ int mutt_alias_complete (char *s, size_t buflen) Aliases = a_cur->next; a_cur->next = NULL; - mutt_free_alias (&a_cur); + alias_delete(&a_cur); if (a_list) a_cur = a_list; @@ -550,47 +535,43 @@ static const format_t *alias_format_str (char *dest, size_t destlen, char op, 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': - if(alias->del) - m_strcpy (dest, sizeof(dest), "D"); - else - m_strcpy (dest, sizeof(dest), " "); + 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), (format_t *) 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); @@ -600,8 +581,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)); @@ -609,8 +590,8 @@ static int alias_SortAlias (const void *a, const void *b) static int alias_SortAddress (const void *a, const void *b) { - address_t *pa = (*(ALIAS **) a)->addr; - address_t *pb = (*(ALIAS **) b)->addr; + address_t *pa = (*(alias_t **) a)->addr; + address_t *pb = (*(alias_t **) b)->addr; int r; if (pa == pb) @@ -632,11 +613,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; @@ -658,8 +639,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: @@ -667,8 +648,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++; } @@ -676,12 +657,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); } @@ -706,7 +687,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++; diff --git a/alias.h b/alias.h index 59086f5..cc0ee57 100644 --- a/alias.h +++ b/alias.h @@ -9,28 +9,34 @@ #ifndef _MUTT_ALIAS_H #define _MUTT_ALIAS_H +#include #include -typedef struct alias { - struct alias *self; /* XXX - ugly hack */ +typedef struct alias_t { + struct alias_t *next; char *name; address_t *addr; - struct alias *next; short tagged; short del; short num; -} ALIAS; +} alias_t; + +DO_INIT(alias_t, alias); +void alias_wipe(alias_t *a); + +DO_NEW(alias_t, alias); +DO_DELETE(alias_t, alias); +DO_SLIST(alias_t, alias); + +address_t *alias_lookup(alias_t *list, const char *s); void mutt_create_alias (ENVELOPE *, address_t *); -int mutt_check_alias_name (const char *, char *); address_t *mutt_get_address (ENVELOPE *, const char **); -address_t *mutt_lookup_alias (const char *s); address_t *mutt_expand_aliases (address_t *); void mutt_expand_aliases_env (ENVELOPE *); -void mutt_free_alias (ALIAS **); address_t *alias_reverse_lookup (address_t *); int mutt_alias_complete (char *, size_t); int mutt_addr_is_user (address_t *); -void mutt_alias_menu (char *, size_t, ALIAS *); +void mutt_alias_menu (char *, size_t, alias_t *); #endif /* !_MUTT_ALIAS_H */ diff --git a/globals.h b/globals.h index 96c439a..48a8842 100644 --- a/globals.h +++ b/globals.h @@ -249,7 +249,7 @@ WHERE SIG_ATOMIC_VOLATILE_T SigWinch INITVAL (0); WHERE int CurrentMenu; -WHERE ALIAS *Aliases INITVAL (0); +WHERE alias_t *Aliases INITVAL (0); WHERE LIST *UserHeader INITVAL (0); /*-- formerly in pgp.h --*/ diff --git a/init.c b/init.c index 218e29c..f137e35 100644 --- a/init.c +++ b/init.c @@ -1384,7 +1384,7 @@ static int parse_unalias (BUFFER * buf, BUFFER * s, unsigned long data __attribute__ ((unused)), BUFFER * err __attribute__ ((unused))) { - ALIAS *tmp, *last = NULL; + alias_t *tmp, *last = NULL; do { mutt_extract_token (buf, s, 0); @@ -1396,7 +1396,7 @@ static int parse_unalias (BUFFER * buf, BUFFER * s, set_option (OPTFORCEREDRAWINDEX); } else - mutt_free_alias (&Aliases); + alias_delete(&Aliases); break; } else @@ -1413,7 +1413,7 @@ static int parse_unalias (BUFFER * buf, BUFFER * s, else Aliases = tmp->next; tmp->next = NULL; - mutt_free_alias (&tmp); + alias_delete(&tmp); break; } last = tmp; @@ -1427,8 +1427,8 @@ static int parse_alias (BUFFER * buf, BUFFER * s, unsigned long data __attribute__ ((unused)), BUFFER * err) { - ALIAS *tmp = Aliases; - ALIAS *last = NULL; + alias_t *tmp = Aliases; + alias_t *last = NULL; char *estr = NULL; if (!MoreArgs (s)) { @@ -1449,8 +1449,7 @@ static int parse_alias (BUFFER * buf, BUFFER * s, if (!tmp) { /* create a new alias */ - tmp = p_new(ALIAS, 1); - tmp->self = tmp; + tmp = alias_new(); tmp->name = m_strdup(buf->data); /* give the main addressbook code a chance */ if (CurrentMenu == MENU_ALIAS) diff --git a/lib-sys/unix.c b/lib-sys/unix.c index 8a1b860..a83d4bc 100644 --- a/lib-sys/unix.c +++ b/lib-sys/unix.c @@ -29,7 +29,7 @@ * otherwise assume that the GECOS field is a comma-separated list. * Replace "&" by a capitalized version of the user's login name. */ -ssize_t mutt_gecos_name(char *dst, ssize_t n, struct passwd *pw, rx_t *rx) +ssize_t mutt_gecos_name(char *dst, ssize_t n, struct passwd *pw, regex_t *rx) { const char *p, *end; ssize_t len; @@ -43,7 +43,7 @@ ssize_t mutt_gecos_name(char *dst, ssize_t n, struct passwd *pw, rx_t *rx) if (rx) { regmatch_t pat_match[1]; - if (regexec(rx->rx, pw->pw_gecos, 1, pat_match, 0)) { + if (regexec(rx, pw->pw_gecos, 1, pat_match, 0)) { return 0; } diff --git a/lib-sys/unix.h b/lib-sys/unix.h index 3172841..43e9340 100644 --- a/lib-sys/unix.h +++ b/lib-sys/unix.h @@ -25,7 +25,7 @@ #include -ssize_t mutt_gecos_name(char *dst, ssize_t n, struct passwd *pw, rx_t *rx); +ssize_t mutt_gecos_name(char *dst, ssize_t n, struct passwd *pw, regex_t *rx); int getdnsdomainname(char *, ssize_t); /* flags for _mutt_system() */ diff --git a/main.c b/main.c index e020974..4ea57e1 100644 --- a/main.c +++ b/main.c @@ -721,7 +721,7 @@ int main (int argc, char **argv) address_t *a; for (; alias_queries; alias_queries = alias_queries->next) { - if ((a = mutt_lookup_alias (alias_queries->data))) { + if ((a = alias_lookup(Aliases, alias_queries->data))) { /* output in machine-readable form */ mutt_addrlist_to_idna (a, NULL); mutt_write_address_list (a, stdout, 0, 0); diff --git a/muttlib.c b/muttlib.c index 28f6af3..27cbdbd 100644 --- a/muttlib.c +++ b/muttlib.c @@ -322,7 +322,7 @@ char *_mutt_expand_path (char *s, size_t slen, int rx) HEADER *h; address_t *alias; - if ((alias = mutt_lookup_alias (s + 1))) { + if ((alias = alias_lookup(Aliases, s + 1))) { h = header_new(); h->env = envelope_new(); h->env->from = h->env->to = alias; @@ -552,19 +552,6 @@ void _mutt_mktemp (char *s, const char *src, int line) unlink (s); } -void mutt_free_alias (ALIAS ** p) -{ - ALIAS *t; - - while (*p) { - t = *p; - *p = (*p)->next; - p_delete(&t->name); - address_delete (&t->addr); - p_delete(&t); - } -} - /* collapse the pathname using ~ or = when possible */ void mutt_pretty_mailbox (char *s) {