Ticket #3090: mutt-3090-references.patch

Makefile.am

@@ -24 +24 @@
         getdomain.c group.c \
         handler.c hash.c hdrline.c headers.c help.c hook.c keymap.c \
         main.c mbox.c menu.c mh.c mx.c pager.c parse.c pattern.c \
-        postpone.c query.c recvattach.c recvcmd.c \
+        postpone.c query.c recvattach.c recvcmd.c references.c \
         rfc822.c rfc1524.c rfc2047.c rfc2231.c rfc3676.c \
         score.c send.c sendlib.c signal.c sort.c \
         status.c system.c thread.c charset.c history.c lib.c \

copy.c

@@ -370 +370 @@
   {
     if ((flags & CH_NOSTATUS) == 0)
     {
-      if (h->env->irt_changed && h->env->in_reply_to)
+      if (h->env->irt_changed)
       {
-        LIST *listp = h->env->in_reply_to;
-
-        if (fputs ("In-Reply-To: ", out) == EOF)
-          return (-1);
-
-        for (; listp; listp = listp->next)
-          if ((fputs (listp->data, out) == EOF) || (fputc (' ', out) == EOF))
-            return (-1);
-
-        if (fputc ('\n', out) == EOF)
-          return (-1);
+        char *s = mutt_in_reply_to_str(h->env);
+        if (s && fprintf (out, "In-Reply-To: %s\n", s) < 0)
+          return -1;
       }
 
-      if (h->env->refs_changed && h->env->references)
+      if (h->env->refs_changed)
       {
-        LIST *listp = h->env->references, *refs = NULL, *t;
-
-        if (fputs ("References: ", out) == EOF)
-          return (-1);
-
-        /* Mutt stores references in reverse order, thus we create
-         * a reordered refs list that we can put in the headers */
-        for (; listp; listp = listp->next, refs = t)
-        {
-          t = (LIST *)safe_malloc (sizeof (LIST));
-          t->data = listp->data;
-          t->next = refs;
-        }
-
-        for (; refs; refs = refs->next)
-          if ((fputs (refs->data, out) == EOF) || (fputc (' ', out) == EOF))
-            return (-1);
-
-        /* clearing refs from memory */
-        for (t = refs; refs; refs = t->next, t = refs)
-          FREE (&refs);
-
-        if (fputc ('\n', out) == EOF)
-          return (-1);
+        char *s = mutt_references_str(h->env, 0);
+        if (s && fprintf (out, "References: %s\n", s) < 0)
+          return -1;
       }
 
       if (h->old || h->read)

hcache.c

@@ -423 +423 @@
 
   d = dump_buffer(e->spam, d, off, convert);
 
-  d = dump_list(e->references, d, off, 0);
-  d = dump_list(e->in_reply_to, d, off, 0);
+  d = dump_char(mutt_references_str(e, 0), d, off, convert);
+  d = dump_char(mutt_in_reply_to_str(e), d, off, convert);
   d = dump_list(e->userhdrs, d, off, convert);
 
   return d;
@@ -460 +460 @@
 
   restore_buffer(&e->spam, d, off, convert);
 
-  restore_list(&e->references, d, off, 0);
-  restore_list(&e->in_reply_to, d, off, 0);
+  restore_char(&e->references_s, d, off, convert);
+  restore_char(&e->in_reply_to_s, d, off, convert);
   restore_list(&e->userhdrs, d, off, convert);
 }
 

headers.c

@@ -111 +111 @@
   mutt_unlink (path);
 
   /* restore old info. */
-  n->references = msg->env->references;
-  msg->env->references = NULL;
+  mutt_move_references (n, msg->env);
 
   mutt_free_envelope (&msg->env);
   msg->env = n; n = NULL;
 
-  if (!msg->env->in_reply_to)
-    mutt_free_list (&msg->env->references);
+  if (!mutt_has_in_reply_to(msg->env))
+    mutt_free_references (msg->env);
 
   mutt_expand_aliases_env (msg->env);
 
-  /* search through the user defined headers added to see if either a 
-   * fcc: or attach-file: field was specified.  
+  /* search through the user defined headers added to see if any of
+   * fcc: or attach-file: or pgp: fields were specified.  
    */
 
   cur = msg->env->userhdrs;
@@ -132 +131 @@
   {
     keep = 1;
 
-    /* keep track of whether or not we see the in-reply-to field.  if we did
-     * not, remove the references: field later so that we can generate a new
-     * message based upon this one.
-     */
     if (fcc && ascii_strncasecmp ("fcc:", cur->data, 4) == 0)
     {
       p = cur->data + 4;
@@ -179 +174 @@
       }
       keep = 0;
     }
-
-
     else if ((WithCrypto & APPLICATION_PGP)
              &&ascii_strncasecmp ("pgp:", cur->data, 4) == 0)
     {

mbox.c

@@ -466 +466 @@
   return (1);
 }
 
-static int strict_cmp_lists (const LIST *a, const LIST *b)
-{
-  while (a && b)
-  {
-    if (mutt_strcmp (a->data, b->data))
-      return (0);
-
-    a = a->next;
-    b = b->next;
-  }
-  if (a || b)
-    return (0);
-
-  return (1);
-}
-
-static int strict_cmp_envelopes (const ENVELOPE *e1, const ENVELOPE *e2)
+static int strict_cmp_envelopes (ENVELOPE *e1, ENVELOPE *e2)
 {
   if (e1 && e2)
   {
     if (mutt_strcmp (e1->message_id, e2->message_id) ||
         mutt_strcmp (e1->subject, e2->subject) ||
-        !strict_cmp_lists (e1->references, e2->references) ||
+        mutt_strcmp (mutt_references_str(e1, 0), mutt_references_str(e2, 0)) ||
         !strict_addrcmp (e1->from, e2->from) ||
         !strict_addrcmp (e1->sender, e2->sender) ||
         !strict_addrcmp (e1->reply_to, e2->reply_to) ||

mutt.h

@@ -596 +596 @@
   char *date;
   char *x_label;
   BUFFER *spam;
-  LIST *references;             /* message references (in reverse order) */
-  LIST *in_reply_to;            /* in-reply-to header content */
+  char *references_s;           /* references header content */
+  LIST *references_l;           /* references (parsed, in reverse order) */
+  char *in_reply_to_s;          /* in-reply-to header content */
+  LIST *in_reply_to_l;          /* in-reply-to (parsed) */
   LIST *userhdrs;               /* user defined headers */
 
   unsigned int irt_changed : 1; /* In-Reply-To changed to link/break threads */
@@ -956 +958 @@
 
 #include "ascii.h"
 #include "protos.h"
+#include "references.h"
 #include "lib.h"
 #include "globals.h"
 

muttlib.c

@@ -677 +677 @@
 
   mutt_buffer_free (&(*p)->spam);
 
-  mutt_free_list (&(*p)->references);
-  mutt_free_list (&(*p)->in_reply_to);
+  mutt_free_references (*p);
+  mutt_free_in_reply_to (*p);
   mutt_free_list (&(*p)->userhdrs);
   FREE (p);             /* __FREE_CHECKED__ */
 }
@@ -703 +703 @@
   MOVE_ELEM(supersedes);
   MOVE_ELEM(date);
   MOVE_ELEM(x_label);
-  if (!base->refs_changed)
+
+  if (!base->refs_changed && !mutt_has_references(base))
   {
-    MOVE_ELEM(references);
+    MOVE_ELEM(references_l);
+    MOVE_ELEM(references_s);
   }
-  if (!base->irt_changed)
+
+  if (!base->irt_changed && !mutt_has_in_reply_to(base))
   {
-    MOVE_ELEM(in_reply_to);
+    MOVE_ELEM(in_reply_to_l);
+    MOVE_ELEM(in_reply_to_s);
   }
-  
+
   /* real_subj is subordinate to subject */
   if (!base->subject)
   {

parse.c

@@ -87 +87 @@
     }
   }
   /* not reached */
-}
-
-static LIST *mutt_parse_references (char *s, int in_reply_to)
-{
-  LIST *t, *lst = NULL;
-  int m, n = 0;
-  char *o = NULL, *new, *at;
-
-  while ((s = strtok (s, " \t;")) != NULL)
-  {
-    /*
-     * some mail clients add other garbage besides message-ids, so do a quick
-     * check to make sure this looks like a valid message-id
-     * some idiotic clients also break their message-ids between lines, deal
-     * with that too (give up if it's more than two lines, though)
-     */
-    t = NULL;
-    new = NULL;
-
-    if (*s == '<')
-    {
-      n = strlen (s);
-      if (s[n-1] != '>')
-      {
-        o = s;
-        s = NULL;
-        continue;
-      }
-
-      new = safe_strdup (s);
-    }
-    else if (o)
-    {
-      m = strlen (s);
-      if (s[m - 1] == '>')
-      {
-        new = safe_malloc (sizeof (char) * (n + m + 1));
-        strcpy (new, o);        /* __STRCPY_CHECKED__ */
-        strcpy (new + n, s);    /* __STRCPY_CHECKED__ */
-      }
-    }
-    if (new)
-    {
-      /* make sure that this really does look like a message-id.
-       * it should have exactly one @, and if we're looking at
-       * an in-reply-to header, make sure that the part before
-       * the @ has more than eight characters or it's probably
-       * an email address
-       */
-      if (!(at = strchr (new, '@')) || strchr (at + 1, '@')
-          || (in_reply_to && at - new <= 8))
-        FREE (&new);
-      else
-      {
-        t = (LIST *) safe_malloc (sizeof (LIST));
-        t->data = new;
-        t->next = lst;
-        lst = t;
-      }
-    }
-    o = NULL;
-    s = NULL;
-  }
-
-  return (lst);
 }
 
 int mutt_check_encoding (const char *c)
@@ -1073 +1008 @@
     case 'i':
     if (!ascii_strcasecmp (line+1, "n-reply-to"))
     {
-      mutt_free_list (&e->in_reply_to);
-      e->in_reply_to = mutt_parse_references (p, 1);
+      mutt_free_list (&e->in_reply_to_l);
+      FREE (&e->in_reply_to_s);
+      e->in_reply_to_s = safe_strdup (p);
       matched = 1;
     }
     break;
@@ -1155 +1091 @@
     case 'r':
     if (!ascii_strcasecmp (line + 1, "eferences"))
     {
-      mutt_free_list (&e->references);
-      e->references = mutt_parse_references (p, 0);
+      mutt_free_list (&e->references_l);
+      FREE (&e->references_s);
+      e->references_s = safe_strdup (p);
       matched = 1;
     }
     else if (!ascii_strcasecmp (line + 1, "eply-to"))

pattern.c

@@ -1015 +1015 @@
   return pat->alladdr; /* No matches, or all matches if alladdr */
 }
 
-static int match_reference (pattern_t *pat, LIST *refs)
-{
-  for (; refs; refs = refs->next)
-    if (patmatch (pat, refs->data) == 0)
-      return 1;
-  return 0;
-}
-
 /*
  * Matches subscribed mailing lists
  */
@@ -1166 +1158 @@
     case M_SIZE:
       return (pat->not ^ (h->content->length >= pat->min && (pat->max == M_MAXRANGE || h->content->length <= pat->max)));
     case M_REFERENCE:
-      return (pat->not ^ match_reference (pat, h->env->references));
+      return (pat->not ^ (mutt_references_str (h->env, 0) &&
+                          patmatch (pat, mutt_references_str (h->env, 0)) == 0));
     case M_ADDRESS:
       return (pat->not ^ match_adrlist (pat, flags & M_MATCH_FULL_ADDRESS, 4,
                                         h->env->from, h->env->sender,

(a) /dev/null vs. (b) b/references.c

@@ +1 @@
+/*
+ * Copyright (C) 1996-2000 Michael R. Elkins <me@mutt.org>
+ * Copyright (C) 2008 Aron Griffis <agriffis@n01se.net>
+ * 
+ *     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.
+ */ 
+
+#if HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include "mutt.h"
+#include "mutt_regex.h"
+#include "mailbox.h"
+#include "mime.h"
+#include "rfc2047.h"
+#include "rfc2231.h"
+#include "mutt_crypt.h"
+#include "url.h"
+
+#include <string.h>
+#include <ctype.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+
+static LIST *mutt_parse_references (char *s, int in_reply_to)
+{
+  LIST *t, *lst = NULL;
+  int m, n = 0;
+  char *o = NULL, *new, *at;
+
+  while ((s = strtok (s, " \t;")) != NULL)
+  {
+    /* some mail clients add other garbage besides message-ids, so do a quick
+     * check to make sure this looks like a valid message-id
+     * some idiotic clients also break their message-ids between lines, deal
+     * with that too (give up if it's more than two lines, though)
+     */
+    t = NULL;
+    new = NULL;
+
+    if (*s == '<')
+    {
+      n = strlen (s);
+      if (s[n-1] != '>')
+      {
+        o = s;
+        s = NULL;
+        continue;
+      }
+
+      new = safe_strdup (s);
+    }
+    else if (o)
+    {
+      m = strlen (s);
+      if (s[m - 1] == '>')
+      {
+        new = safe_malloc (sizeof (char) * (n + m + 1));
+        strcpy (new, o);        /* __STRCPY_CHECKED__ */
+        strcpy (new + n, s);    /* __STRCPY_CHECKED__ */
+      }
+    }
+    if (new)
+    {
+      /* make sure that this really does look like a message-id.
+       * it should have exactly one @, and if we're looking at
+       * an in-reply-to header, make sure that the part before
+       * the @ has more than eight characters or it's probably
+       * an email address
+       */
+      if (!(at = strchr (new, '@')) || strchr (at + 1, '@')
+          || (in_reply_to && at - new <= 8))
+        FREE (&new);
+      else
+      {
+        t = (LIST *) safe_malloc (sizeof (LIST));
+        t->data = new;
+        t->next = lst;
+        lst = t;
+      }
+    }
+    o = NULL;
+    s = NULL;
+  }
+
+  return (lst);
+}
+
+LIST *mutt_references_list (ENVELOPE *e)
+{
+  if (!e->references_l && e->references_s)
+    e->references_l = mutt_parse_references (e->references_s, 0);
+  return e->references_l;
+}
+
+LIST *mutt_in_reply_to_list (ENVELOPE *e)
+{
+  if (!e->in_reply_to_l && e->in_reply_to_s)
+    e->in_reply_to_l = mutt_parse_references (e->in_reply_to_s, 1);
+  return e->in_reply_to_l;
+}
+
+LIST **mutt_references_listp (ENVELOPE *e)
+{
+  /* giving away a pointer invalidates the stored string */
+  (void) mutt_references_list (e);
+  FREE (&e->references_s);
+  return &e->references_l;
+}
+
+LIST **mutt_in_reply_to_listp (ENVELOPE *e)
+{
+  /* giving away a pointer invalidates the stored string */
+  (void) mutt_in_reply_to_list (e);
+  FREE (&e->in_reply_to_s);
+  return &e->in_reply_to_l;
+}
+
+/* this is a generally useful function that should probably live elsewhere */
+static void reverse_list (LIST **list)
+{
+  LIST *l = *list, *prev = NULL, *next = NULL;
+  if (!l || !l->next)
+    return;
+  do {
+    next = l->next;
+    l->next = prev;
+    prev = l;
+    l = next;
+  } while (l);
+  *list = prev;
+}
+
+static char *refs_str (char **sp, LIST *l, int max)
+{
+  LIST *ref;
+  int len, buflen, count;
+  char *s = NULL;
+
+  /* if no max then preemptively return stored value */
+  if (!max && *sp)
+    return *sp;
+
+  /* list is stored in reverse order to speed up threading;
+   * switch it forward temporarily.
+   */
+  reverse_list (&l);
+
+  for (ref = l, count = 0, buflen = 0;
+       ref && (max == 0 || count < max);
+       ref = ref->next, count++)
+  {
+    len = strlen (ref->data);
+    buflen += len + 1;
+    safe_realloc (&s, buflen);
+    memcpy (&s[buflen - len - 1], ref->data, len);
+    s[buflen - 1] = ' ';
+  }
+  if (s)
+    s[buflen - 1] = '\0';
+
+  /* reverse it back */
+  reverse_list (&l);
+
+  if (!max)
+    *sp = s;
+
+  return s;
+}
+
+char *mutt_references_str (ENVELOPE *e, int max)
+{
+  if (max)
+  {
+    /* make sure the list is populated, since specifying a max value
+     * forces the list-to-string generation.
+     */
+    (void) mutt_references_list (e);
+  }
+  return refs_str (&e->references_s, e->references_l, max);
+}
+
+char *mutt_in_reply_to_str (ENVELOPE *e)
+{
+  return refs_str (&e->in_reply_to_s, e->in_reply_to_l, 1);
+}
+
+void mutt_move_references (ENVELOPE *to, ENVELOPE *from)
+{
+  to->references_l = from->references_l;
+  to->references_s = from->references_s;
+  from->references_l = NULL;
+  from->references_s = NULL;
+}
+
+void mutt_free_references (ENVELOPE *e)
+{
+  mutt_free_list (&e->references_l);
+  FREE (&e->references_s);
+}
+
+void mutt_free_in_reply_to (ENVELOPE *e)
+{
+  mutt_free_list (&e->in_reply_to_l);
+  FREE (&e->in_reply_to_s);
+}
+
+void mutt_null_references (ENVELOPE *e)
+{
+  e->references_l = NULL;
+  e->references_s = NULL;
+}
+
+void mutt_null_in_reply_to (ENVELOPE *e)
+{
+  e->in_reply_to_l = NULL;
+  e->in_reply_to_s = NULL;
+}
+
+void mutt_set_in_reply_to_s (ENVELOPE *e, char *s)
+{
+  mutt_free_list (&e->in_reply_to_l);
+  FREE (&e->in_reply_to_s);
+  e->in_reply_to_s = safe_strdup (s);
+}
+

(a) /dev/null vs. (b) b/references.h

@@ +1 @@
+/*
+ * Copyright (C) 1996-2000 Michael R. Elkins <me@mutt.org>
+ * Copyright (C) 2008 Aron Griffis <agriffis@n01se.net>
+ * 
+ *     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.
+ */ 
+
+LIST *mutt_references_list (ENVELOPE *e);
+LIST **mutt_references_listp (ENVELOPE *e);
+char *mutt_references_str (ENVELOPE *e, int max);
+void mutt_null_references (ENVELOPE *e);
+void mutt_move_references (ENVELOPE *to, ENVELOPE *from);
+void mutt_free_references (ENVELOPE *e);
+
+LIST *mutt_in_reply_to_list (ENVELOPE *e);
+LIST **mutt_in_reply_to_listp (ENVELOPE *e);
+char *mutt_in_reply_to_str (ENVELOPE *e);
+void mutt_null_in_reply_to (ENVELOPE *e);
+void mutt_set_in_reply_to_s (ENVELOPE *e, char *s);
+void mutt_free_in_reply_to (ENVELOPE *e);
+
+#define mutt_has_references(e) ((e)->references_s || (e)->references_l)
+#define mutt_has_in_reply_to(e) ((e)->in_reply_to_s || (e)->in_reply_to_l)

send.c

@@ -565 +565 @@
 {
   LIST *t = NULL, *l = NULL;
 
-  if (e->references)
-    l = mutt_copy_list (e->references);
-  else
-    l = mutt_copy_list (e->in_reply_to);
+  if (mutt_has_references (e))
+    l = mutt_copy_list (mutt_references_list (e));
+  else if (mutt_has_in_reply_to (e))
+    l = mutt_copy_list (mutt_in_reply_to_list (e));
   
   if (e->message_id)
   {
@@ -636 +636 @@
   if (pp) p = *pp;
   if (qq) q = *qq;
   
-  if (!p) p = &env->references;
-  if (!q) q = &env->in_reply_to;
+  /* make sure the lists are populated */
+  if (!p) p = mutt_references_listp (env);
+  if (!q) q = mutt_in_reply_to_listp (env);
   
   while (*p) p = &(*p)->next;
   while (*q) q = &(*q)->next;
@@ -658 +659 @@
 static void 
 mutt_make_reference_headers (ENVELOPE *curenv, ENVELOPE *env, CONTEXT *ctx)
 {
-  env->references = NULL;
-  env->in_reply_to = NULL;
+  mutt_null_references (env);
+  mutt_null_in_reply_to (env);
   
   if (!curenv)
   {

sendlib.c

@@ -1517 +1517 @@
   fputc ('\n', fp);
 }
 
-/* arbitrary number of elements to grow the array by */
-#define REF_INC 16
-
-#define TrimRef 10
-
-/* need to write the list in reverse because they are stored in reverse order
- * when parsed to speed up threading
- */
-static void write_references (LIST *r, FILE *f)
-{
-  LIST **ref = NULL;
-  int refcnt = 0, refmax = 0;
-
-  for ( ; (TrimRef == 0 || refcnt < TrimRef) && r ; r = r->next)
-  {
-    if (refcnt == refmax)
-      safe_realloc (&ref, (refmax += REF_INC) * sizeof (LIST *));
-    ref[refcnt++] = r;
-  }
-
-  while (refcnt-- > 0)
-  {
-    fputc (' ', f);
-    fputs (ref[refcnt]->data, f);
-  }
-
-  FREE (&ref);
-}
-
-
 static void foldingstrfcpy (char *d, const char *s, int n)
 {
   while (--n >= 0 && *s)
@@ -1822 +1792 @@
 
   if (mode <= 0)
   {
-    if (env->references)
-    {
-      fputs ("References:", fp);
-      write_references (env->references, fp);
-      fputc('\n', fp);
-    }
+    if (mutt_has_references (env))
+      fprintf (fp, "References: %s\n", mutt_references_str (env, 10));
 
     /* Add the MIME headers */
     fputs ("MIME-Version: 1.0\n", fp);
     mutt_write_mime_header (attach, fp);
   }
 
-  if (env->in_reply_to)
-  {
-    fputs ("In-Reply-To:", fp);
-    write_references (env->in_reply_to, fp);
-    fputc ('\n', fp);
-  }
+  if (mutt_has_in_reply_to (env))
+    fprintf (fp, "In-Reply-To: %s\n", mutt_in_reply_to_str (env));
   
   /* Add any user defined headers */
   for (; tmp; tmp = tmp->next)

thread.c

@@ -888 +888 @@
       if (using_refs == 0)
       {
         /* look at the beginning of in-reply-to: */
-        if ((ref = cur->env->in_reply_to) != NULL)
+        if ((ref = mutt_in_reply_to_list (cur->env)) != NULL)
           using_refs = 1;
         else
         {
-          ref = cur->env->references;
+          ref = mutt_references_list (cur->env);
           using_refs = 2;
         }
       }
@@ -904 +904 @@
          * the second reference (since at least eudora puts the most
          * recent reference in in-reply-to and the rest in references)
          */