X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=muttlib.c;h=04c0b3a28ff15fecb9443da0947b9e9c51637600;hp=f4b5e27dfa66b66ed6366e97cf48cf2325c2fc00;hb=5e6273c09929249ee7a850934bf12fd03439d923;hpb=4dc555afd969ac7aed5c50db80ff9df17ed39e47

diff --git a/muttlib.c b/muttlib.c
index f4b5e27..04c0b3a 100644
--- a/muttlib.c
+++ b/muttlib.c
@@ -12,13 +12,22 @@
 # include "config.h"
 #endif
 
+#include <lib-lib/mem.h>
+#include <lib-lib/ascii.h>
+#include <lib-lib/str.h>
+#include <lib-lib/macros.h>
+#include <lib-lib/buffer.h>
+#include <lib-lib/file.h>
+
 #include "mutt.h"
+#include "enter.h"
 #include "mutt_curses.h"
 #include "mime.h"
 #include "mx.h"
 #include "url.h"
+#include "attach.h"
 
-#include "reldate.h"
+#include "version.h"
 
 #ifdef USE_IMAP
 #include "imap.h"
@@ -27,9 +36,6 @@
 
 #include "mutt_crypt.h"
 
-#include "lib/mem.h"
-#include "lib/intl.h"
-#include "lib/str.h"
 #include "lib/debug.h"
 
 #include <string.h>
@@ -44,9 +50,11 @@
 #include <sys/types.h>
 #include <utime.h>
 
+#define SW              (option(OPTMBOXPANE)?SidebarWidth:0)
+
 BODY *mutt_new_body (void)
 {
-  BODY *p = (BODY *) safe_calloc (1, sizeof (BODY));
+  BODY *p = p_new(BODY, 1);
 
   p->disposition = DISPATTACH;
   p->use_disp = 1;
@@ -60,7 +68,7 @@ BODY *mutt_new_body (void)
  * Renamed to mutt_adv_mktemp so I only have to change where it's
  * called, and not all possible cases.
  */
-void mutt_adv_mktemp (char *s, size_t l)
+void mutt_adv_mktemp (const char* dir, char *s, size_t l)
 {
   char buf[_POSIX_PATH_MAX];
   char tmp[_POSIX_PATH_MAX];
@@ -68,14 +76,14 @@ void mutt_adv_mktemp (char *s, size_t l)
   size_t sl;
   struct stat sb;
 
-  strfcpy (buf, NONULL (Tempdir), sizeof (buf));
+  m_strcpy(buf, sizeof(buf), m_strisempty(dir) ? NONULL(Tempdir) : dir);
   mutt_expand_path (buf, sizeof (buf));
   if (s[0] == '\0') {
     snprintf (s, l, "%s/muttXXXXXX", buf);
     mktemp (s);
   }
   else {
-    strfcpy (tmp, s, sizeof (tmp));
+    m_strcpy(tmp, sizeof(tmp), s);
     mutt_sanitize_filename (tmp, 1);
     snprintf (s, l, "%s/%s", buf, tmp);
     if (lstat (s, &sb) == -1 && errno == ENOENT)
@@ -86,8 +94,8 @@ void mutt_adv_mktemp (char *s, size_t l)
     mktemp (s);
     if (period != NULL) {
       *period = '.';
-      sl = safe_strlen (s);
-      strfcpy (s + sl, period, l - sl);
+      sl = m_strlen(s);
+      m_strcpy(s + sl, l - sl, period);
     }
   }
 }
@@ -105,14 +113,14 @@ int mutt_copy_body (FILE * fp, BODY ** tgt, BODY * src)
 
   if (src->filename) {
     use_disp = 1;
-    strfcpy (tmp, src->filename, sizeof (tmp));
+    m_strcpy(tmp, sizeof(tmp), src->filename);
   }
   else {
     use_disp = 0;
     tmp[0] = '\0';
   }
 
-  mutt_adv_mktemp (tmp, sizeof (tmp));
+  mutt_adv_mktemp (NULL, tmp, sizeof (tmp));
   if (mutt_save_attachment (fp, src, tmp, 0, NULL) == -1)
     return -1;
 
@@ -123,19 +131,19 @@ int mutt_copy_body (FILE * fp, BODY ** tgt, BODY * src)
   b->parts = NULL;
   b->next = NULL;
 
-  b->filename = safe_strdup (tmp);
+  b->filename = m_strdup(tmp);
   b->use_disp = use_disp;
   b->unlink = 1;
 
   if (mutt_is_text_part (b))
     b->noconv = 1;
 
-  b->xtype = safe_strdup (b->xtype);
-  b->subtype = safe_strdup (b->subtype);
-  b->form_name = safe_strdup (b->form_name);
-  b->filename = safe_strdup (b->filename);
-  b->d_filename = safe_strdup (b->d_filename);
-  b->description = safe_strdup (b->description);
+  b->xtype = m_strdup(b->xtype);
+  b->subtype = m_strdup(b->subtype);
+  b->form_name = m_strdup(b->form_name);
+  b->filename = m_strdup(b->filename);
+  b->d_filename = m_strdup(b->d_filename);
+  b->description = m_strdup(b->description);
 
   /* 
    * we don't seem to need the HEADER structure currently.
@@ -149,8 +157,8 @@ int mutt_copy_body (FILE * fp, BODY ** tgt, BODY * src)
   for (par = b->parameter, ppar = &b->parameter; par;
        ppar = &(*ppar)->next, par = par->next) {
     *ppar = mutt_new_parameter ();
-    (*ppar)->attribute = safe_strdup (par->attribute);
-    (*ppar)->value = safe_strdup (par->value);
+    (*ppar)->attribute = m_strdup(par->attribute);
+    (*ppar)->value = m_strdup(par->value);
   }
 
   mutt_stamp_attachment (b);
@@ -177,12 +185,12 @@ void mutt_free_body (BODY ** p)
     else if (b->filename)
       debug_print (1, ("not unlinking %s.\n", b->filename));
 
-    FREE (&b->filename);
-    FREE (&b->content);
-    FREE (&b->xtype);
-    FREE (&b->subtype);
-    FREE (&b->description);
-    FREE (&b->form_name);
+    p_delete(&b->filename);
+    p_delete(&b->content);
+    p_delete(&b->xtype);
+    p_delete(&b->subtype);
+    p_delete(&b->description);
+    p_delete(&b->form_name);
 
     if (b->hdr) {
       /* Don't free twice (b->hdr->content = b->parts) */
@@ -193,7 +201,7 @@ void mutt_free_body (BODY ** p)
     if (b->parts)
       mutt_free_body (&b->parts);
 
-    FREE (&b);
+    p_delete(&b);
   }
 
   *p = 0;
@@ -205,46 +213,15 @@ void mutt_free_parameter (PARAMETER ** p)
   PARAMETER *o;
 
   while (t) {
-    FREE (&t->attribute);
-    FREE (&t->value);
+    p_delete(&t->attribute);
+    p_delete(&t->value);
     o = t;
     t = t->next;
-    FREE (&o);
+    p_delete(&o);
   }
   *p = 0;
 }
 
-LIST *mutt_add_list (LIST * head, const char *data)
-{
-  LIST *tmp;
-
-  for (tmp = head; tmp && tmp->next; tmp = tmp->next);
-  if (tmp) {
-    tmp->next = safe_malloc (sizeof (LIST));
-    tmp = tmp->next;
-  }
-  else
-    head = tmp = safe_malloc (sizeof (LIST));
-
-  tmp->data = safe_strdup (data);
-  tmp->next = NULL;
-  return head;
-}
-
-void mutt_free_list (LIST ** list)
-{
-  LIST *p;
-
-  if (!list)
-    return;
-  while (*list) {
-    p = *list;
-    *list = (*list)->next;
-    FREE (&p->data);
-    FREE (&p);
-  }
-}
-
 HEADER *mutt_dup_header (HEADER * h)
 {
   HEADER *hnew;
@@ -260,50 +237,50 @@ void mutt_free_header (HEADER ** h)
     return;
   mutt_free_envelope (&(*h)->env);
   mutt_free_body (&(*h)->content);
-  FREE (&(*h)->maildir_flags);
-  FREE (&(*h)->tree);
-  FREE (&(*h)->path);
+  p_delete(&(*h)->maildir_flags);
+  p_delete(&(*h)->tree);
+  p_delete(&(*h)->path);
 #ifdef MIXMASTER
   mutt_free_list (&(*h)->chain);
 #endif
 #if defined USE_POP || defined USE_IMAP || defined USE_NNTP
-  FREE (&(*h)->data);
+  p_delete(&(*h)->data);
 #endif
-  FREE (h);
+  p_delete(h);
 }
 
 /* returns true if the header contained in "s" is in list "t" */
 int mutt_matches_ignore (const char *s, LIST * t)
 {
   for (; t; t = t->next) {
-    if (!ascii_strncasecmp (s, t->data, safe_strlen (t->data))
+    if (!ascii_strncasecmp (s, t->data, m_strlen(t->data))
         || *t->data == '*')
       return 1;
   }
   return 0;
 }
 
-/* prepend the path part of *path to *link */
-void mutt_expand_link (char *newpath, const char *path, const char *link)
+/* prepend the path part of *path to *lnk */
+void mutt_expand_link (char *newpath, const char *path, const char *lnk)
 {
   const char *lb = NULL;
   size_t len;
 
-  /* link is full path */
-  if (*link == '/') {
-    strfcpy (newpath, link, _POSIX_PATH_MAX);
+  /* lnk is full path */
+  if (*lnk == '/') {
+    m_strcpy(newpath, _POSIX_PATH_MAX, lnk);
     return;
   }
 
   if ((lb = strrchr (path, '/')) == NULL) {
-    /* no path in link */
-    strfcpy (newpath, link, _POSIX_PATH_MAX);
+    /* no path in lnk */
+    m_strcpy(newpath, _POSIX_PATH_MAX, lnk);
     return;
   }
 
   len = lb - path + 1;
   memcpy (newpath, path, len);
-  strfcpy (newpath + len, link, _POSIX_PATH_MAX - len);
+  m_strcpy(newpath + len, _POSIX_PATH_MAX - len, lnk);
 }
 
 char *mutt_expand_path (char *s, size_t slen)
@@ -318,7 +295,7 @@ char *_mutt_expand_path (char *s, size_t slen, int rx)
   char tmp[_POSIX_PATH_MAX];
   char *t;
 
-  char *tail = "";
+  const char *tail = "";
 
   int recurse = 0;
 
@@ -329,7 +306,7 @@ char *_mutt_expand_path (char *s, size_t slen, int rx)
     case '~':
       {
         if (*(s + 1) == '/' || *(s + 1) == 0) {
-          strfcpy (p, NONULL (Homedir), sizeof (p));
+          m_strcpy(p, sizeof(p), NONULL(Homedir));
           tail = s + 1;
         }
         else {
@@ -339,7 +316,7 @@ char *_mutt_expand_path (char *s, size_t slen, int rx)
             *t = 0;
 
           if ((pw = getpwnam (s + 1))) {
-            strfcpy (p, pw->pw_dir, sizeof (p));
+            m_strcpy(p, sizeof(p), pw->pw_dir);
             if (t) {
               *t = '/';
               tail = t;
@@ -362,11 +339,10 @@ char *_mutt_expand_path (char *s, size_t slen, int rx)
     case '+':
       {
 #ifdef USE_IMAP
-        /* if folder = {host} or imap[s]://host/: don't append slash */
-        if (imap_is_magic (NONULL (Maildir), NULL) == M_IMAP &&
-            (Maildir[safe_strlen (Maildir) - 1] == '}' ||
-             Maildir[safe_strlen (Maildir) - 1] == '/'))
-          strfcpy (p, NONULL (Maildir), sizeof (p));
+        /* if folder = imap[s]://host/: don't append slash */
+        if (imap_is_magic (NONULL (Maildir), NULL) == M_IMAP && 
+            Maildir[m_strlen(Maildir) - 1] == '/')
+          m_strcpy(p, sizeof(p), NONULL(Maildir));
         else
 #endif
           snprintf (p, sizeof (p), "%s/", NONULL (Maildir));
@@ -400,14 +376,14 @@ char *_mutt_expand_path (char *s, size_t slen, int rx)
 
     case '>':
       {
-        strfcpy (p, NONULL (Inbox), sizeof (p));
+        m_strcpy(p, sizeof(p), NONULL(Inbox));
         tail = s + 1;
       }
       break;
 
     case '<':
       {
-        strfcpy (p, NONULL (Outbox), sizeof (p));
+        m_strcpy(p, sizeof(p), NONULL(Outbox));
         tail = s + 1;
       }
       break;
@@ -415,11 +391,11 @@ char *_mutt_expand_path (char *s, size_t slen, int rx)
     case '!':
       {
         if (*(s + 1) == '!') {
-          strfcpy (p, NONULL (LastFolder), sizeof (p));
+          m_strcpy(p, sizeof(p), NONULL(LastFolder));
           tail = s + 2;
         }
         else {
-          strfcpy (p, NONULL (Spoolfile), sizeof (p));
+          m_strcpy(p, sizeof(p), NONULL(Spoolfile));
           tail = s + 1;
         }
       }
@@ -427,14 +403,14 @@ char *_mutt_expand_path (char *s, size_t slen, int rx)
 
     case '-':
       {
-        strfcpy (p, NONULL (LastFolder), sizeof (p));
+        m_strcpy(p, sizeof(p), NONULL(LastFolder));
         tail = s + 1;
       }
       break;
 
     case '^':
       {
-        strfcpy (p, NONULL (CurrentFolder), sizeof (p));
+        m_strcpy(p, sizeof(p), NONULL(CurrentFolder));
         tail = s + 1;
       }
       break;
@@ -453,17 +429,10 @@ char *_mutt_expand_path (char *s, size_t slen, int rx)
     else
       snprintf (tmp, sizeof (tmp), "%s%s", p, tail);
 
-    strfcpy (s, tmp, slen);
+    m_strcpy(s, slen, tmp);
   }
   while (recurse);
 
-#ifdef USE_IMAP
-  /* Rewrite IMAP path in canonical form - aids in string comparisons of
-   * folders. May possibly fail, in which case s should be the same. */
-  if (imap_is_magic (s, NULL) == M_IMAP)
-    imap_expand_path (s, slen);
-#endif
-
   return (s);
 }
 
@@ -485,19 +454,19 @@ char *mutt_gecos_name (char *dest, size_t destlen, struct passwd *pw)
   if (!pw || !pw->pw_gecos)
     return NULL;
 
-  memset (dest, 0, destlen);
+  p_clear(dest, destlen);
 
   if (GecosMask.rx) {
     if (regexec (GecosMask.rx, pw->pw_gecos, 1, pat_match, 0) == 0)
-      strfcpy (dest, pw->pw_gecos + pat_match[0].rm_so,
-               MIN (pat_match[0].rm_eo - pat_match[0].rm_so + 1, destlen));
+      m_strcpy(dest, MIN(pat_match[0].rm_eo - pat_match[0].rm_so + 1, destlen),
+               pw->pw_gecos + pat_match[0].rm_so);
   }
   else if ((p = strchr (pw->pw_gecos, ',')))
-    strfcpy (dest, pw->pw_gecos, MIN (destlen, p - pw->pw_gecos + 1));
+    m_strcpy(dest, MIN(destlen, p - pw->pw_gecos + 1), pw->pw_gecos);
   else
-    strfcpy (dest, pw->pw_gecos, destlen);
+    m_strcpy(dest, destlen, pw->pw_gecos);
 
-  pwnl = safe_strlen (pw->pw_name);
+  pwnl = m_strlen(pw->pw_name);
 
   for (idx = 0; dest[idx]; idx++) {
     if (dest[idx] == '&') {
@@ -539,8 +508,8 @@ void mutt_set_parameter (const char *attribute, const char *value,
   }
 
   q = mutt_new_parameter ();
-  q->attribute = safe_strdup (attribute);
-  q->value = safe_strdup (value);
+  q->attribute = m_strdup(attribute);
+  q->value = m_strdup(value);
   q->next = *p;
   *p = q;
 }
@@ -623,34 +592,78 @@ void mutt_free_envelope (ENVELOPE ** p)
   rfc822_free_address (&(*p)->reply_to);
   rfc822_free_address (&(*p)->mail_followup_to);
 
-  FREE (&(*p)->list_post);
-  FREE (&(*p)->subject);
+  p_delete(&(*p)->list_post);
+  p_delete(&(*p)->subject);
   /* real_subj is just an offset to subject and shouldn't be freed */
-  FREE (&(*p)->message_id);
-  FREE (&(*p)->supersedes);
-  FREE (&(*p)->date);
-  FREE (&(*p)->x_label);
-  FREE (&(*p)->organization);
+  p_delete(&(*p)->message_id);
+  p_delete(&(*p)->supersedes);
+  p_delete(&(*p)->date);
+  p_delete(&(*p)->x_label);
+  p_delete(&(*p)->organization);
 #ifdef USE_NNTP
-  FREE (&(*p)->newsgroups);
-  FREE (&(*p)->xref);
-  FREE (&(*p)->followup_to);
-  FREE (&(*p)->x_comment_to);
+  p_delete(&(*p)->newsgroups);
+  p_delete(&(*p)->xref);
+  p_delete(&(*p)->followup_to);
+  p_delete(&(*p)->x_comment_to);
 #endif
 
   mutt_buffer_free (&(*p)->spam);
   mutt_free_list (&(*p)->references);
   mutt_free_list (&(*p)->in_reply_to);
   mutt_free_list (&(*p)->userhdrs);
-  FREE (p);
+  p_delete(p);
+}
+
+/* move all the headers from extra not present in base into base */
+void mutt_merge_envelopes(ENVELOPE* base, ENVELOPE** extra)
+{
+  /* copies each existing element if necessary, and sets the element
+  * to NULL in the source so that mutt_free_envelope doesn't leave us
+  * with dangling pointers. */
+#define MOVE_ELEM(h) if (!base->h) { base->h = (*extra)->h; (*extra)->h = NULL; }
+  MOVE_ELEM(return_path);
+  MOVE_ELEM(from);
+  MOVE_ELEM(to);
+  MOVE_ELEM(cc);
+  MOVE_ELEM(bcc);
+  MOVE_ELEM(sender);
+  MOVE_ELEM(reply_to);
+  MOVE_ELEM(mail_followup_to);
+  MOVE_ELEM(list_post);
+  MOVE_ELEM(message_id);
+  MOVE_ELEM(supersedes);
+  MOVE_ELEM(date);
+  MOVE_ELEM(x_label);
+  if (!base->refs_changed) {
+    MOVE_ELEM(references);
+  }
+  if (!base->irt_changed) {
+    MOVE_ELEM(in_reply_to);
+  }
+  /* real_subj is subordinate to subject */
+  if (!base->subject) {
+    base->subject = (*extra)->subject;
+    base->real_subj = (*extra)->real_subj;
+    (*extra)->subject = NULL;
+    (*extra)->real_subj = NULL;
+  }
+  /* spam and user headers should never be hashed, and the new envelope may
+   * have better values. Use new versions regardless. */
+  mutt_buffer_free (&base->spam);
+  mutt_free_list (&base->userhdrs);
+  MOVE_ELEM(spam);
+  MOVE_ELEM(userhdrs);
+#undef MOVE_ELEM
+  
+  mutt_free_envelope(extra);
 }
 
 void _mutt_mktemp (char *s, const char *src, int line)
 {
 
-  snprintf (s, _POSIX_PATH_MAX, "%s/muttng-%s-%d-%d-%d-%x", NONULL (Tempdir),
+  snprintf (s, _POSIX_PATH_MAX, "%s/muttng-%s-%d-%d-%d-%x%x", NONULL (Tempdir),
             NONULL (Hostname), (int) getuid (), (int) getpid (), Counter++, 
-            (unsigned int) rand());
+            (unsigned int) rand(), (unsigned int) rand());
   debug_print (1, ("%s:%d: mutt_mktemp returns \"%s\".\n", src, line, s));
   unlink (s);
 }
@@ -662,9 +675,9 @@ void mutt_free_alias (ALIAS ** p)
   while (*p) {
     t = *p;
     *p = (*p)->next;
-    FREE (&t->name);
+    p_delete(&t->name);
     rfc822_free_address (&t->addr);
-    FREE (&t);
+    p_delete(&t);
   }
 }
 
@@ -709,22 +722,22 @@ void mutt_pretty_mailbox (char *s)
   }
   *q = 0;
 
-  if (safe_strncmp (s, Maildir, (len = safe_strlen (Maildir))) == 0 &&
+  if (m_strncmp(s, Maildir, (len = m_strlen(Maildir))) == 0 &&
       s[len] == '/') {
     *s++ = '=';
-    memmove (s, s + len, safe_strlen (s + len) + 1);
+    memmove (s, s + len, m_strlen(s + len) + 1);
   }
-  else if (safe_strncmp (s, Homedir, (len = safe_strlen (Homedir))) == 0 &&
+  else if (m_strncmp(s, Homedir, (len = m_strlen(Homedir))) == 0 &&
            s[len] == '/') {
     *s++ = '~';
-    memmove (s, s + len - 1, safe_strlen (s + len - 1) + 1);
+    memmove (s, s + len - 1, m_strlen(s + len - 1) + 1);
   }
 }
 
 void mutt_pretty_size (char *s, size_t len, long n)
 {
   if (n == 0)
-    strfcpy (s, "0K", len);
+    m_strcpy(s, len, "0K");
   else if (n < 10189)           /* 0.1K - 9.9K */
     snprintf (s, len, "%3.1fK", (n < 103) ? 0.1 : n / 1024.0);
   else if (n < 1023949) {       /* 10K - 999K */
@@ -757,7 +770,7 @@ void mutt_expand_fmt (char *dest, size_t destlen, const char *fmt,
   size_t slen;
   int found = 0;
 
-  slen = safe_strlen (src);
+  slen = m_strlen(src);
   destlen--;
 
   for (p = fmt, d = dest; destlen && *p; p++) {
@@ -769,7 +782,7 @@ void mutt_expand_fmt (char *dest, size_t destlen, const char *fmt,
         break;
       case 's':
         found = 1;
-        strfcpy (d, src, destlen + 1);
+        m_strcpy(d, destlen + 1, src);
         d += destlen > slen ? slen : destlen;
         destlen -= destlen > slen ? slen : destlen;
         p++;
@@ -789,8 +802,8 @@ void mutt_expand_fmt (char *dest, size_t destlen, const char *fmt,
   *d = '\0';
 
   if (!found && destlen > 0) {
-    safe_strcat (dest, destlen, " ");
-    safe_strcat (dest, destlen, src);
+    m_strcat(dest, destlen, " ");
+    m_strcat(dest, destlen, src);
   }
 
 }
@@ -804,7 +817,7 @@ int mutt_check_overwrite (const char *attname, const char *path,
   char tmp[_POSIX_PATH_MAX];
   struct stat st;
 
-  strfcpy (fname, path, flen);
+  m_strcpy(fname, flen, path);
   if (access (fname, F_OK) != 0)
     return 0;
   if (stat (fname, &st) != 0)
@@ -818,13 +831,13 @@ int mutt_check_overwrite (const char *attname, const char *path,
         str_replace (directory, fname);
         break;
       case 1:                  /* yes */
-        FREE (directory);
+        p_delete(directory);
         break;
       case -1:                 /* abort */
-        FREE (directory);
+        p_delete(directory);
         return -1;
       case 2:                  /* no */
-        FREE (directory);
+        p_delete(directory);
         return 1;
       }
     }
@@ -839,10 +852,10 @@ int mutt_check_overwrite (const char *attname, const char *path,
       if (mutt_get_field (_("File under directory: "), tmp, sizeof (tmp),
                           M_FILE | M_CLEAR) != 0 || !tmp[0])
         return (-1);
-      mutt_concat_path (fname, path, tmp, flen);
+      mutt_concat_path(fname, flen, path, tmp);
     }
     else
-      mutt_concat_path (fname, path, mutt_basename (attname), flen);
+      mutt_concat_path(fname, flen, path, mutt_basename(attname));
   }
 
   if (*append == 0 && access (fname, F_OK) == 0) {
@@ -868,7 +881,7 @@ int mutt_check_overwrite (const char *attname, const char *path,
 void mutt_save_path (char *d, size_t dsize, ADDRESS * a)
 {
   if (a && a->mailbox) {
-    strfcpy (d, a->mailbox, dsize);
+    m_strcpy(d, dsize, a->mailbox);
     if (!option (OPTSAVEADDRESS)) {
       char *p;
 
@@ -909,7 +922,7 @@ int mutt_skipchars (const char *s, const char *c)
     ret++;
     s++;
   }
-  return (safe_strlen (p));
+  return (m_strlen(p));
 }
 
 void mutt_FormatString (char *dest,     /* output buffer */
@@ -1003,13 +1016,11 @@ void mutt_FormatString (char *dest,     /* output buffer */
         if (DrawFullLine || option (OPTSTATUSONTOP))
           count = (COLS < destlen ? COLS : destlen);
         else
-          count =
-            ((COLS - SidebarWidth) <
-             destlen ? (COLS - SidebarWidth) : destlen);
+          count = ((COLS - SW) < destlen ? (COLS - SW) : destlen);
         if (count > col) {
           count -= col;         /* how many columns left on this line */
           mutt_FormatString (buf, sizeof (buf), src, callback, data, flags);
-          wid = safe_strlen (buf);
+          wid = m_strlen(buf);
           if (count > wid) {
             count -= wid;       /* how many chars to pad */
             memset (wptr, ch, count);
@@ -1040,12 +1051,12 @@ void mutt_FormatString (char *dest,     /* output buffer */
         break;                  /* skip rest of input */
       }
       else {
-        short tolower = 0;
+        short lower = 0;
         short nodots = 0;
 
         while (ch == '_' || ch == ':') {
           if (ch == '_')
-            tolower = 1;
+            lower = 1;
           else if (ch == ':')
             nodots = 1;
 
@@ -1057,7 +1068,7 @@ void mutt_FormatString (char *dest,     /* output buffer */
           callback (buf, sizeof (buf), ch, src, prefix, ifstring, elsestring,
                     data, flags);
 
-        if (tolower)
+        if (lower)
           str_tolower (buf);
         if (nodots) {
           char *p = buf;
@@ -1067,7 +1078,7 @@ void mutt_FormatString (char *dest,     /* output buffer */
               *p = '_';
         }
 
-        if ((len = safe_strlen (buf)) + wlen > destlen)
+        if ((len = m_strlen(buf)) + wlen > destlen)
           len = (destlen - wlen > 0) ? (destlen - wlen) : 0;
 
         memcpy (wptr, buf, len);
@@ -1106,15 +1117,14 @@ void mutt_FormatString (char *dest,     /* output buffer */
     }
     else {
       unsigned int bar = mutt_skipchars (src, "%\\");
-      char *bar2 = safe_malloc (bar + 1);
+      char *bar2 = p_dupstr(src, bar);
 
-      strfcpy (bar2, src, bar + 1);
       while (bar--) {
         *wptr++ = *src++;
         wlen++;
       }
       col += mutt_strwidth (bar2);
-      FREE (&bar2);
+      p_delete(&bar2);
     }
   }
   *wptr = 0;
@@ -1135,32 +1145,26 @@ void mutt_FormatString (char *dest,     /* output buffer */
    then we assume it is a commmand to run instead of a normal file. */
 FILE *mutt_open_read (const char *path, pid_t * thepid)
 {
-  FILE *f;
-  struct stat s;
-
-  int len = safe_strlen (path);
-
-  if (path[len - 1] == '|') {
-    /* read from a pipe */
-
-    char *s = safe_strdup (path);
-
-    s[len - 1] = 0;
-    mutt_endwin (NULL);
-    *thepid = mutt_create_filter (s, NULL, &f, NULL);
-    FREE (&s);
-  }
-  else {
-    if (stat (path, &s) < 0)
-      return (NULL);
-    if (S_ISDIR (s.st_mode)) {
-      errno = EINVAL;
-      return (NULL);
+    int len = m_strlen(path);
+    FILE *f;
+
+    if (path[len - 1] == '|') {
+        char *s = m_strdup(path);
+
+        /* read from a pipe */
+
+        s[len - 1] = 0;
+        mutt_endwin (NULL);
+        *thepid = mutt_create_filter (s, NULL, &f, NULL);
+        p_delete(&s);
+    } else {
+        f = fopen (path, "r");
+        if (!f)
+            return NULL;
+        *thepid = -1;
     }
-    f = fopen (path, "r");
-    *thepid = -1;
-  }
-  return (f);
+
+    return (f);
 }
 
 /* returns 0 if OK to proceed, -1 to abort, 1 to retry */
@@ -1189,16 +1193,10 @@ int mutt_save_confirm (const char *s, struct stat *st)
   }
 #endif
 
-  if (stat (s, st) != -1) {
-    if (magic == -1) {
-      mutt_error (_("%s is not a mailbox!"), s);
-      return 1;
-    }
-
+  if (magic > 0 && !mx_access (s, W_OK)) {
     if (option (OPTCONFIRMAPPEND) &&
-        (!TrashPath || (safe_strcmp (s, TrashPath) != 0)))
+        (!TrashPath || (m_strcmp(s, TrashPath) != 0))) {
       /* if we're appending to the trash, there's no point in asking */
-    {
       snprintf (tmp, sizeof (tmp), _("Append messages to %s?"), s);
       if ((rc = mutt_yesorno (tmp, M_YES)) == M_NO)
         ret = 1;
@@ -1206,6 +1204,13 @@ int mutt_save_confirm (const char *s, struct stat *st)
         ret = -1;
     }
   }
+
+  if (stat (s, st) != -1) {
+    if (magic == -1) {
+      mutt_error (_("%s is not a mailbox!"), s);
+      return 1;
+    }
+  }
   else {
 #ifdef USE_IMAP
     if (magic != M_IMAP)
@@ -1234,81 +1239,6 @@ int mutt_save_confirm (const char *s, struct stat *st)
   return (ret);
 }
 
-void state_prefix_putc (char c, STATE * s)
-{
-  if (s->flags & M_PENDINGPREFIX) {
-    int i;
-
-    i = safe_strlen (Quotebuf);
-    Quotebuf[i++] = c;
-    Quotebuf[i] = '\0';
-    if (i == sizeof (Quotebuf) - 1 || c == '\n') {
-      char buf[2 * SHORT_STRING];
-      int j = 0, offset = 0;
-      regmatch_t pmatch[1];
-
-      state_reset_prefix (s);
-      while (regexec
-             ((regex_t *) QuoteRegexp.rx, &Quotebuf[offset], 1, pmatch,
-              0) == 0)
-        offset += pmatch->rm_eo;
-
-      if (!option (OPTQUOTEEMPTY) && Quotebuf[offset] == '\n') {
-        buf[0] = '\n';
-        buf[1] = '\0';
-      }
-      else if (option (OPTQUOTEQUOTED) && offset) {
-        for (i = 0; i < offset; i++)
-          if (Quotebuf[i] != ' ')
-            j = i;
-        strncpy (buf, Quotebuf, j + 1);
-        strcpy (buf + j + 1, Quotebuf + j);
-      }
-      else
-        snprintf (buf, sizeof (buf), "%s%s", NONULL (s->prefix), Quotebuf);
-
-      state_puts (buf, s);
-    }
-  }
-  else
-    state_putc (c, s);
-
-  if (c == '\n') {
-    state_set_prefix (s);
-    Quotebuf[0] = '\0';
-  }
-}
-
-int state_printf (STATE * s, const char *fmt, ...)
-{
-  int rv;
-  va_list ap;
-
-  va_start (ap, fmt);
-  rv = vfprintf (s->fpout, fmt, ap);
-  va_end (ap);
-
-  return rv;
-}
-
-void state_mark_attach (STATE * s)
-{
-  if ((s->flags & M_DISPLAY) && !safe_strcmp (Pager, "builtin"))
-    state_puts (AttachmentMarker, s);
-}
-
-void state_attach_puts (const char *t, STATE * s)
-{
-  if (*t != '\n')
-    state_mark_attach (s);
-  while (*t) {
-    state_putc (*t, s);
-    if (*t++ == '\n' && *t)
-      if (*t != '\n')
-        state_mark_attach (s);
-  }
-}
-
 void mutt_display_sanitize (char *s)
 {
   for (; *s; s++) {
@@ -1325,87 +1255,7 @@ void mutt_sleep (short s)
     sleep (s);
 }
 
-/*
- * Creates and initializes a BUFFER*. If passed an existing BUFFER*,
- * just initializes. Frees anything already in the buffer.
- *
- * Disregards the 'destroy' flag, which seems reserved for caller.
- * This is bad, but there's no apparent protocol for it.
- */
-BUFFER *mutt_buffer_init (BUFFER * b)
-{
-  if (!b) {
-    b = safe_malloc (sizeof (BUFFER));
-    if (!b)
-      return NULL;
-  }
-  else {
-    FREE(&b->data);
-  }
-  memset (b, 0, sizeof (BUFFER));
-  return b;
-}
-
-/*
- * Creates and initializes a BUFFER*. If passed an existing BUFFER*,
- * just initializes. Frees anything already in the buffer. Copies in
- * the seed string.
- *
- * Disregards the 'destroy' flag, which seems reserved for caller.
- * This is bad, but there's no apparent protocol for it.
- */
-BUFFER *mutt_buffer_from (BUFFER * b, char *seed)
-{
-  if (!seed)
-    return NULL;
-
-  b = mutt_buffer_init (b);
-  b->data = safe_strdup (seed);
-  b->dsize = safe_strlen (seed);
-  b->dptr = (char *) b->data + b->dsize;
-  return b;
-}
-
-void mutt_buffer_addstr (BUFFER * buf, const char *s)
-{
-  mutt_buffer_add (buf, s, safe_strlen (s));
-}
-
-void mutt_buffer_addch (BUFFER * buf, char c)
-{
-  mutt_buffer_add (buf, &c, 1);
-}
-
-void mutt_buffer_free (BUFFER ** p)
-{
-  if (!p || !*p)
-    return;
-
-  FREE (&(*p)->data);
-  /* dptr is just an offset to data and shouldn't be freed */
-  FREE (p);
-}
-
-/* dynamically grows a BUFFER to accomodate s, in increments of 128 bytes.
- * Always one byte bigger than necessary for the null terminator, and
- * the buffer is always null-terminated */
-void mutt_buffer_add (BUFFER * buf, const char *s, size_t len)
-{
-  size_t offset;
-
-  if (buf->dptr + len + 1 > buf->data + buf->dsize) {
-    offset = buf->dptr - buf->data;
-    buf->dsize += len < 128 ? 128 : len + 1;
-    safe_realloc ((void **) &buf->data, buf->dsize);
-    buf->dptr = buf->data + offset;
-  }
-  memcpy (buf->dptr, s, len);
-  buf->dptr += len;
-  *(buf->dptr) = '\0';
-}
-
 /* Decrease a file's modification time by 1 second */
-
 time_t mutt_decrease_mtime (const char *f, struct stat *st)
 {
   struct utimbuf utim;
@@ -1428,12 +1278,29 @@ time_t mutt_decrease_mtime (const char *f, struct stat *st)
   return mtime;
 }
 
-const char *mutt_make_version (void)
+/* sets mtime of 'to' to mtime of 'from' */
+void mutt_set_mtime (const char* from, const char* to) {
+  struct utimbuf utim;
+  struct stat st;
+
+  if (stat (from, &st) != -1) {
+    utim.actime = st.st_mtime;
+    utim.modtime = st.st_mtime;
+    utime (to, &utim);
+  }
+}
+
+const char *mutt_make_version (int full)
 {
   static char vstring[STRING];
 
-  snprintf (vstring, sizeof (vstring), "Mutt-ng %s (%s) based on Mutt 1.5.9",
-            MUTT_VERSION, ReleaseDate);
+  if (full)
+    snprintf (vstring, sizeof (vstring),
+              "Mutt-ng %s-r%s (based on Mutt 1.5.11)",
+              MUTT_VERSION, MUTT_REVISION);
+  else
+    snprintf (vstring, sizeof (vstring), "mutt-ng/%s-r%s",
+              MUTT_VERSION, MUTT_REVISION);
   return vstring;
 }
 
@@ -1447,8 +1314,8 @@ void mutt_free_spam_list (SPAM_LIST ** list)
     p = *list;
     *list = (*list)->next;
     rx_free (&p->rx);
-    FREE(&p->template);
-    FREE(&p);
+    p_delete(&p->template);
+    p_delete(&p);
   }
 }
 
@@ -1467,7 +1334,7 @@ int mutt_match_spam_list (const char *s, SPAM_LIST * l, char *text, int x)
   for (; l; l = l->next) {
     /* If this pattern needs more matches, expand pmatch. */
     if (l->nmatch > nmatch) {
-      safe_realloc (&pmatch, l->nmatch * sizeof (regmatch_t));
+      p_realloc(&pmatch, l->nmatch);
       nmatch = l->nmatch;
     }
 
@@ -1481,7 +1348,7 @@ int mutt_match_spam_list (const char *s, SPAM_LIST * l, char *text, int x)
       for (p = l->template; *p;) {
         if (*p == '%') {
           n = atoi (++p);       /* find pmatch index */
-          while (isdigit (*p))
+          while (isdigit ((unsigned char) *p))
             ++p;                /* skip subst token */
           for (i = pmatch[n].rm_so; (i < pmatch[n].rm_eo) && (tlen < x); i++)
             text[tlen++] = s[i];
@@ -1498,3 +1365,111 @@ int mutt_match_spam_list (const char *s, SPAM_LIST * l, char *text, int x)
 
   return 0;
 }
+
+int mutt_cmp_header (const HEADER * h1, const HEADER * h2) {
+  if (h1 && h2) {
+    if (h1->received != h2->received ||
+        h1->date_sent != h2->date_sent ||
+        h1->content->length != h2->content->length ||
+        h1->lines != h2->lines ||
+        h1->zhours != h2->zhours ||
+        h1->zminutes != h2->zminutes ||
+        h1->zoccident != h2->zoccident ||
+        h1->mime != h2->mime ||
+        !mutt_cmp_env (h1->env, h2->env) ||
+        !mutt_cmp_body (h1->content, h2->content))
+      return (0);
+    else
+      return (1);
+  }
+  else {
+    if (h1 == NULL && h2 == NULL)
+      return (1);
+    else
+      return (0);
+  }
+}
+
+/* return 1 if address lists are strictly identical */
+int mutt_cmp_addr (const ADDRESS * a, const ADDRESS * b)
+{
+  while (a && b) {
+    if (m_strcmp(a->mailbox, b->mailbox) ||
+        m_strcmp(a->personal, b->personal))
+      return (0);
+
+    a = a->next;
+    b = b->next;
+  }
+  if (a || b)
+    return (0);
+
+  return (1);
+}
+
+int mutt_cmp_list (const LIST * a, const LIST * b)
+{
+  while (a && b) {
+    if (m_strcmp(a->data, b->data))
+      return (0);
+
+    a = a->next;
+    b = b->next;
+  }
+  if (a || b)
+    return (0);
+
+  return (1);
+}
+
+int mutt_cmp_env (const ENVELOPE * e1, const ENVELOPE * e2)
+{
+  if (e1 && e2) {
+    if (m_strcmp(e1->message_id, e2->message_id) ||
+        m_strcmp(e1->subject, e2->subject) ||
+        !mutt_cmp_list (e1->references, e2->references) ||
+        !mutt_cmp_addr (e1->from, e2->from) ||
+        !mutt_cmp_addr (e1->sender, e2->sender) ||
+        !mutt_cmp_addr (e1->reply_to, e2->reply_to) ||
+        !mutt_cmp_addr (e1->to, e2->to) ||
+        !mutt_cmp_addr (e1->cc, e2->cc) ||
+        !mutt_cmp_addr (e1->return_path, e2->return_path))
+      return (0);
+    else
+      return (1);
+  }
+  else {
+    if (e1 == NULL && e2 == NULL)
+      return (1);
+    else
+      return (0);
+  }
+}
+
+int mutt_cmp_param (const PARAMETER * p1, const PARAMETER * p2)
+{
+  while (p1 && p2) {
+    if (m_strcmp(p1->attribute, p2->attribute) ||
+        m_strcmp(p1->value, p2->value))
+      return (0);
+
+    p1 = p1->next;
+    p2 = p2->next;
+  }
+  if (p1 || p2)
+    return (0);
+
+  return (1);
+}
+
+int mutt_cmp_body (const BODY * b1, const BODY * b2)
+{
+  if (b1->type != b2->type ||
+      b1->encoding != b2->encoding ||
+      m_strcmp(b1->subtype, b2->subtype) ||
+      m_strcmp(b1->description, b2->description) ||
+      !mutt_cmp_param (b1->parameter, b2->parameter) ||
+      b1->length != b2->length)
+    return (0);
+  return (1);
+}