X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=alias.c;h=7282a8c4cb91d962640685de68fe68573e504187;hp=e8f109b337b141dbb653082a2cb76a937e6016cf;hb=2480626d883af3c291e94b90e1edc1ca40fca1c4;hpb=4a0b020a3048f079979bea43c04f9fe388f9354d diff --git a/alias.c b/alias.c index e8f109b..7282a8c 100644 --- a/alias.c +++ b/alias.c @@ -20,14 +20,15 @@ #include #include #include +#include +#include + +#include #include #include #include -#include "lib/rx.h" -#include "lib/debug.h" - #include "mutt.h" #include "mutt_idna.h" #include "sort.h" @@ -35,24 +36,249 @@ #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; +} + +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))) + { + return 1; + } + + return rx_list_match(Alternates, addr->mailbox) + && !rx_list_match(UnAlternates, addr->mailbox); +} + +address_t *mutt_get_address(ENVELOPE *env, const char **pfxp) +{ +#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 + * 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) { - ALIAS *t = Aliases; + 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); - for (; t; t = t->next) - if (!m_strcasecmp(s, t->name)) - return (t->addr); - return (NULL); /* no such alias */ + 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; @@ -63,7 +289,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; @@ -101,8 +327,8 @@ static address_t *mutt_expand_aliases_r (address_t * a, LIST ** expn) if (pw) { char namebuf[STRING]; - mutt_gecos_name (namebuf, sizeof (namebuf), pw); - m_strreplace (&a->personal, namebuf); + mutt_gecos_name(namebuf, sizeof (namebuf), pw, GecosMask.rx); + m_strreplace(&a->personal, namebuf); } } } @@ -146,233 +372,13 @@ 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; - const char *pfx = NULL; - - if (mutt_addr_is_user (env->from)) { - if (env->to && !mutt_is_mail_list (env->to)) { - pfx = "To"; - adr = env->to; - } - 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; -} - -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) @@ -397,8 +403,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; @@ -433,12 +439,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; @@ -468,7 +474,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; @@ -484,64 +490,6 @@ 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_t * 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 format_t *alias_format_str (char *dest, size_t destlen, char op, const format_t *src, const char *fmt, const char *ifstring __attribute__ ((unused)), @@ -549,47 +497,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); @@ -599,8 +543,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)); @@ -608,8 +552,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) @@ -631,11 +575,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; @@ -657,8 +601,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: @@ -666,8 +610,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++; } @@ -675,12 +619,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); } @@ -705,7 +649,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++;