begin to work on alias.[hc]

ALIAS -> alias_t.
make some functions better.

Signed-off-by: Pierre Habouzit <madcoder@debian.org>

diff --git a/alias.c b/alias.c
index fa83c6f..add8028 100644 (file)
--- a/alias.c
+++ b/alias.c
@@ -36,24 +36,199 @@
 #define RSORT(x) (SortAlias & SORT_REVERSE) ? -x : x
 
 static struct mapping_t AliasHelp[] = {
 #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 <me@mutt.org>
+ * 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 <me@mutt.org>
+ * 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 <me@mutt.org>
+ * since that would get aliased as
+ *     alias me Michael \\`/bin/rm -f ~\\` Elkins <me@mutt.org>
+ * 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;
 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) {
   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;
 
       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 <me@mutt.org>
- * 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 <me@mutt.org>
- * 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 <me@mutt.org>
- * since that would get aliased as
- *     alias me Michael \\`/bin/rm -f ~\\` Elkins <me@mutt.org>
- * 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;
 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;
 }
 
   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)
 {
 /*
  * 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)
   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)
 {
  */
 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;
 
   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 */
       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 {
           else {

-            a_cur->next = p_new(ALIAS, 1);
+            a_cur->next = alias_new();

             a_cur = a_cur->next;
           }
             a_cur = a_cur->next;
           }

-          memcpy (a_cur, a, sizeof (ALIAS));
+          *a_cur = *a;

           a_cur->next = NULL;
         }
         a = a->next;
           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;
         Aliases = a_cur->next;
 
       a_cur->next = NULL;

-      mutt_free_alias (&a_cur);
+      alias_delete(&a_cur);

 
       if (a_list)
         a_cur = a_list;
 
       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];
                                      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':
 
   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':
     break;
   case 'a':

-    mutt_format_s (dest, destlen, fmt, alias->name);
+    mutt_format_s(dest, destlen, fmt, alias->name);

     break;
   case 'r':
     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':
     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':
     break;
   case 't':

-    dest[0] = alias->tagged ? '*' : ' ';
-    dest[1] = 0;
+    m_strcpy(dest, destlen, alias->tagged ? "*" : " ");

     break;
   }
 
   return (src);
 }
 
     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)
 {
                      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);
   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)
 {
 
 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));
   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)
 {
 
 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)
   int r;
 
   if (pa == pb)


@@ -632,11 +613,11 @@ static int alias_SortAddress (const void *a, const void *b)
   return (RSORT (r));
 }
 
   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;
   MUTTMENU *menu;

-  ALIAS **AliasTable = NULL;
+  alias_t **AliasTable = NULL;

   int t = -1;
   int i, done = 0;
   int op;
   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->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:
 
 
 new_aliases:
 


@@ -667,8 +648,8 @@ new_aliases:
 
   /* count the number of aliases */
   for (aliasp = aliases; aliasp; aliasp = aliasp->next) {
 
   /* 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++;
   }
 
     menu->max++;
   }
 


@@ -676,12 +657,12 @@ new_aliases:
   menu->data = AliasTable;
 
   for (i = omax, aliasp = aliases; aliasp; aliasp = aliasp->next, i++) {
   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) {
     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);
   }
            (SortAlias & SORT_MASK) ==
            SORT_ADDRESS ? alias_SortAddress : alias_SortAlias);
   }


@@ -706,7 +687,7 @@ new_aliases:
         menu->redraw |= REDRAW_INDEX;
       }
       else {
         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++;
         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 (file)
--- a/alias.h
+++ b/alias.h
@@ -9,28 +9,34 @@
 #ifndef _MUTT_ALIAS_H
 #define _MUTT_ALIAS_H
 
 #ifndef _MUTT_ALIAS_H
 #define _MUTT_ALIAS_H
 

+#include <lib-lib/list.h>

 #include <lib-mime/mime.h>
 
 #include <lib-mime/mime.h>
 

-typedef struct alias {
-  struct alias *self;           /* XXX - ugly hack */
+typedef struct alias_t {
+  struct alias_t *next;

   char *name;
   address_t *addr;
   char *name;
   address_t *addr;

-  struct alias *next;

   short tagged;
   short del;
   short num;
   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 *);
 
 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_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 *);
 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 *);
 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 */
 
 #endif /* !_MUTT_ALIAS_H */

diff --git a/globals.h b/globals.h
index 96c439a..48a8842 100644 (file)
--- a/globals.h
+++ b/globals.h
@@ -249,7 +249,7 @@ WHERE SIG_ATOMIC_VOLATILE_T SigWinch INITVAL (0);
 
 WHERE int CurrentMenu;
 
 
 WHERE int CurrentMenu;
 

-WHERE ALIAS *Aliases INITVAL (0);
+WHERE alias_t *Aliases INITVAL (0);

 WHERE LIST *UserHeader INITVAL (0);
 
 /*-- formerly in pgp.h --*/
 WHERE LIST *UserHeader INITVAL (0);
 
 /*-- formerly in pgp.h --*/

diff --git a/init.c b/init.c
index 218e29c..f137e35 100644 (file)
--- 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)))
 {
                           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);
 
   do {
     mutt_extract_token (buf, s, 0);


@@ -1396,7 +1396,7 @@ static int parse_unalias (BUFFER * buf, BUFFER * s,
         set_option (OPTFORCEREDRAWINDEX);
       }
       else
         set_option (OPTFORCEREDRAWINDEX);
       }
       else

-        mutt_free_alias (&Aliases);
+        alias_delete(&Aliases);

       break;
     }
     else
       break;
     }
     else


@@ -1413,7 +1413,7 @@ static int parse_unalias (BUFFER * buf, BUFFER * s,
           else
             Aliases = tmp->next;
           tmp->next = NULL;
           else
             Aliases = tmp->next;
           tmp->next = NULL;

-          mutt_free_alias (&tmp);
+          alias_delete(&tmp);

           break;
         }
         last = tmp;
           break;
         }
         last = tmp;


@@ -1427,8 +1427,8 @@ static int parse_alias (BUFFER * buf, BUFFER * s,
                         unsigned long data __attribute__ ((unused)),
                         BUFFER * err)
 {
                         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)) {
   char *estr = NULL;
 
   if (!MoreArgs (s)) {


@@ -1449,8 +1449,7 @@ static int parse_alias (BUFFER * buf, BUFFER * s,
 
   if (!tmp) {
     /* create a new alias */
 
   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)
     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 (file)
--- 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.
  */
  * 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;
 {
     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 (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;
         }
 
             return 0;
         }
 

diff --git a/lib-sys/unix.h b/lib-sys/unix.h
index 3172841..43e9340 100644 (file)
--- a/lib-sys/unix.h
+++ b/lib-sys/unix.h
@@ -25,7 +25,7 @@
 
 #include <lib-lib/rx.h>
 
 
 #include <lib-lib/rx.h>
 

-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() */
 int getdnsdomainname(char *, ssize_t);
 
 /* flags for _mutt_system() */

diff --git a/main.c b/main.c
index e020974..4ea57e1 100644 (file)
--- 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) {
     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);
         /* 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 (file)
--- 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;
 
         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;
           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);
 }
 
   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)
 {
 /* collapse the pathname using ~ or = when possible */
 void mutt_pretty_mailbox (char *s)
 {